精华内容
下载资源
问答
  • 需求:开发当中我们需要规范和方法注释格式...注意:这里需要在.c前面加’/’,不然会失效。后面.m同理 4.方法注释 模板: ** * @author txf * @params $params$ * @return $returns$ * @description $

    需求:在开发当中我们需要规范类和方法的注释的格式以便后期维护和项目开发当中的协同

    1.创建类注释模板

    在这里插入图片描述
    模板

    **
     * @author txf
     * @date $date$
     * @description $end$
     */
    

    2.绑定参数对应到库方法

    在这里插入图片描述

    3.测试

    在这里插入图片描述
    注意:这里需要在.c前面加’/’,不然会失效。后面的.m同理

    4.方法注释

    在这里插入图片描述
    模板

    **
     * @author txf
     * @params $params$
     * @return $returns$
     * @description $end$
     * @date $date$
     */
    

    5.效果

    在这里插入图片描述

    展开全文
  • css3中自定义变量

    千次阅读 2019-09-29 22:32:26
    使用过Less或者Sass人都知道,为了方便,可以将css属性值定义为一个变量,这样其他元素中需要使用话只需输入变量名就可以了,不过,没使用了前面两者,但又想定义变量人有福了,css3已经支持定制变量。...

    使用过Less或者Sass的人都知道,为了方便,可以将css属性值定义为一个变量,这样在其他元素中需要使用的话只需输入变量名就可以了,在css3中支持定制变量。
    css3中,定义一个变量需要加前缀“- -”,类似于PHP中的变量需要带一个$。

    :root {
    	--box-color: red;
    }
    

    :root 这个 CSS 伪类匹配文档树的根元素。对于 HTML 来说,:root 表示 元素,除了优先级更高之外,与 html 选择器相同。

    上面在:root中定义了一个–box-color:red 变量,变量- -box-color的值为red
    在css3中使用变量需要使用一个var();然后将所需的变量写在var()中,注意,使用变量不能少了- -(两个减号)
    格式:

    元素 {
    属性:var(变量名);
    }

    现在来使用它

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
        <style>
            :root {
                /*定义一个变量--box-color*/
                --box-color: red;
            }
    
            div {
                width: 100px;
                height: 100px;
                background-color: var(--box-color);
            }
        </style>
    </head>
    <body>
    <div></div>
    <div></div>
    </body>
    </html>
    

    在body里面添加两个宽高皆为100px的div,然后为这两个div设置背景色,注意background-color的属性值
    运行看看
    在这里插入图片描述
    可以看到,两个div背景色都被设置为了红色
    那么问题来了

    1. :root代表html元素,而上面所写的两个div都是html的子类(后代),所以,在:root中的定义的变量我们能使用。如果,我们将变量定义在其他元素的作用域({}包围的)中,这个变量还能生效吗?
      首先修改上面的代码,添加一个div的兄弟元素p,在p中定义一个变量- -bg-color:yellow,并在div中使用这个变量

      <!DOCTYPE html>
      <html lang="en">
      <head>
          <meta charset="UTF-8">
          <title>Title</title>
          <style>
              p {
                  /*定义一个变量*/
                  --bg-color: yellow;
              }
      
              div {
                  /*为了看清,添加一个边框*/
                  border: 1px solid blue;
                  width: 100px;
                  height: 100px;
                  background-color: var(--bg-color);
              }
          </style>
      </head>
      <body>
      <p>我是p</p>
      <div></div>
      <br/>
      <div></div>
      </body>
      </html>
      

      运行
      在这里插入图片描述
      可以发现,div的背景色并没有被设置为黄色,这是因为,一个元素定义的变量,只能被自己和自己的后代所使用。

    2. 在html中定义一个变量 - -bg-color:red; ,在body中定义一个相同的变量 - -bg-color:yellow,那么上面的div会被设置为什么背景色?(提示:css选择器有优先级),这个问题留给你们,自己动手实验实验。

    展开全文
  • 智能家居越来越流行,智能家居中我们常要表现一些数据百分比 圆形度条中间个图是一种非常流行的自定义View 1.第一步 你首先需要进行继承View public class CircleProgressImageView extends View 2.第二...

    智能家居越来越流行,在智能家居中我们常要表现一些数据的百分比 圆形度条中间加个图是一种非常流行的自定义View

    1.第一步 你首先需要对类进行继承View

    public class CircleProgressImageView extends View
    2.第二步 要实现三个构造方法 并且前面少参数的调用当前多参数的构造方法

    public CircleProgressImageView(Context context) {
        this(context,null);
    }
    
    public CircleProgressImageView(Context context, AttributeSet attrs) {
        this(context, attrs,0);
    }
    
    public CircleProgressImageView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context,attrs,defStyleAttr);
    }
    3.第三步:取自定义属性 并且对画笔 等进行初始化

    private void init(Context context, AttributeSet attrs, int defStyleAttr) {
        this.context=context;
        /**
         * 获取自定义属性
         */
        TypedArray a=context.obtainStyledAttributes(attrs,R.styleable.CIRCLEPROGRESSIMAGEVIEWATTRS);
        bitmap=a.getResourceId(R.styleable.CIRCLEPROGRESSIMAGEVIEWATTRS_imagers,R.mipmap.ic_launcher);
        /**
         * 把图片资源转为Bitmap对象
         */
        drawBitmap=BitmapFactory.decodeResource(context.getResources(),bitmap);
        /**
         * 初始化RectF对象
         */
        mRectF=new RectF();
        mPaint=new Paint();
        mPaint.setAntiAlias(true);
    
    }
    4.第四步:是在onMeasure方法中对height 和width进行处理

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        /**
         * 获取当前View的宽高
         */
        width=this.getWidth();
        height=this.getHeight();
        /**
         * 对其左右上下进行处理
         */
        mRectF.left=mCircleStoreWidth/2;
        mRectF.top=mCircleStoreWidth/2;
        mRectF.right=width-mCircleStoreWidth/2;
        mRectF.bottom=width-mCircleStoreWidth/2;
    }

    5.这时候我们需要对ondraw()方法进行绘制了

    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawColor(Color.TRANSPARENT);
    
        //画圆北京
        mPaint.setColor(getResources().getColor(R.color.orange));
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeWidth(mCircleStoreWidth);
        canvas.drawArc(mRectF,-90,360,false,mPaint);
        /**
         * 画圆弧的进度显示
         */
        mPaint.setColor(getResources().getColor((R.color.gray)));
        canvas.drawArc(mRectF,-90,((float) mProcessValue/mMaxProcessValue)*360,false,mPaint);
        Log.d(TAG,((float) mProcessValue/mMaxProcessValue)*360+"");
        /**
         * 画中间的图
         */
        float imageLeft=width/2-drawBitmap.getWidth()/2;
        float imageTop=height/2-drawBitmap.getHeight()/2;
        canvas.drawBitmap(drawBitmap,imageLeft,imageTop,mPaint);
    }
    这样我们就实现了一个非常好看和简单的自定义View 自定义属性参考其他文章 这里就不细说了 

    但是这个View是不会转动的 只有通过MainActivity在线程中设置setmProcessValue(processValue)调用改变值就可以转动了。

    源码下载


    展开全文
  • java常用工具类的使用

    热门讨论 2012-03-19 20:11:37
    类的大部分构造器和方法都已经过时,但是该类使用非常方便,因此目前使用还很普遍,该类的另一个主要功能是,数据库操作中,它允许将毫秒值表示为SQL DATE值,是数据库操作中java.sql.Date的父类。关于数据库...
  • 一个就是使用继承。比方说,你可以先创建一个颜色处理器...总结起来,可以得知,在类的继承结构不能仅用树状去表示,如上面的具有交叉继承结构的时候,就建议用接口了。但是,如果是简单的树状结构,我觉得还是用类继承...
  • 类名前面加@Component进行实例化beans.xml中用构造函数实例化对象——普通值、数组,list,set、Map和Properties、自定义类型实例化、给自定义类型初始化数据、给自定义类型初始化数据——推荐引用方式、...

    在类名前面加@Component进行实例化类、在beans.xml中用构造函数实例化对象——普通值、数组,list,set、Map和Properties、自定义类型实例化、给自定义类型初始化数据、给自定义类型初始化数据——推荐引用方式、接口注入实现类(实现接口回调)重点啊!!!

    SpringMvcSSM框架

    源码获取github

    1.目录结构(需要的jar包均在环境搭建中有)

    2.在类名前面加@Component进行实例化类

    @Component//(value = “hsUser”) //相当于 (value = “hsUser”)就是id=hsUser

    beans.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
          http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
          http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    
         <!--1.启动Spring注解-->
        <context:annotation-config/>
        <!--2.扫描注解-->
        <context:component-scan base-package="com.hs"/> 
    
    </beans>

    User.java

    package com.hs.model;
    
    import org.springframework.stereotype.Component;
    
    import java.util.*;
    
    @Component//(value = "hsUser")  //相当于<bean class="com.hs.model.User" id="user"/> (value = "hsUser")就是id=hsUser
    public class User {
    
       private String user_name;
       private Integer user_id;
       private String[] hobbyArray;
       private List<String> hobbyList;
       private Set<String> hobbySet;
       private Map<String, Object> map;
       private Properties properties;  //Map<string,string>
    
       private Role hsRole;    //这是自定义类型
    
       private ITest hsTest;   //定义接口变量
    
       /**
        * 这里通过bean.xml构造函数初始化
        * 1.ITestImpl testImpl = new ITestImpl();
        * 2.hsTest = testImpl
        * 3.ITest hsTest = new ITestImpl();
        * 典型的接口回调嘛
        * @param hsTest
        */
       public User(ITest hsTest) {
          this.hsTest = hsTest;
       }
    
       public User(Role hsRole) {
          this.hsRole = hsRole;
       }
    
       private User() {
       }
    
       public User(Map<String, Object> map, Properties properties) {
          this.map = map;
          this.properties = properties;
       }
    
       public User(Integer user_id, String user_name) {
          this.user_name = user_name;
          this.user_id = user_id;
       }
    
       public User(String user_name, Integer user_id, String[] hobbyArray, List<String> hobbyList, Set<String> hobbySet) {
          this.user_name = user_name;
          this.user_id = user_id;
          this.hobbyArray = hobbyArray;
          this.hobbyList = hobbyList;
          this.hobbySet = hobbySet;
       }
    
       public String getUser_name() {
          return user_name;
       }
    
       public void setUser_name(String user_name) {
          this.user_name = user_name;
       }
    
       public Integer getUser_id() {
          return user_id;
       }
    
       public void setUser_id(Integer user_id) {
          this.user_id = user_id;
       }
    
       public String[] getHobbyArray() {
          return hobbyArray;
       }
    
       public void setHobbyArray(String[] hobbyArray) {
          this.hobbyArray = hobbyArray;
       }
    
       public List<String> getHobbyList() {
          return hobbyList;
       }
    
       public void setHobbyList(List<String> hobbyList) {
          this.hobbyList = hobbyList;
       }
    
       public Set<String> getHobbySet() {
          return hobbySet;
       }
    
       public void setHobbySet(Set<String> hobbySet) {
          this.hobbySet = hobbySet;
       }
    
       public Map<String, Object> getMap() {
          return map;
       }
    
       public void setMap(Map<String, Object> map) {
          this.map = map;
       }
    
       public Properties getProperties() {
          return properties;
       }
    
       public void setProperties(Properties properties) {
          this.properties = properties;
       }
    
       public Role getHsRole() {
          return hsRole;
       }
    
       public void setHsRole(Role hsRole) {
          this.hsRole = hsRole;
       }
    
       public ITest getHsTest() {
          return hsTest;
       }
    
       public void setHsTest(ITest hsTest) {
          this.hsTest = hsTest;
       }
    
       @Override
       public String toString() {
          return "User{" +
                "user_name='" + user_name + '\'' +
                ", user_id=" + user_id +
                ", hobbyArray=" + Arrays.toString(hobbyArray) +
                ", hobbyList=" + hobbyList +
                ", hobbySet=" + hobbySet +
                ", map=" + map +
                ", properties=" + properties +
                ", hsRole=" + hsRole +
                ", hsTest=" + hsTest +
                '}';
       }
    }

    ConstructorObjectTest.java

    /**
     * 测试在类名前面加@Component进行实例化类
     */
    @Test
    public void test01() {
       ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    
       User user = ac.getBean("user",User.class);
       System.out.println(user);
    }

    3.在beans.xml中用构造函数实例化对象——普通值

    在spring中实例化对象,把类的构造函数设置成private,依然可以被实例化,在java中就不能被实例化

    只要见到标签就是实例化。。。

    User.java

     public User(Integer user_id, String user_name) {
          this.user_name = user_name;
          this.user_id = user_id;
       }

    beans.xml

    <!--User 类通过构造函数实例化-->
    <bean id="user01" class="com.hs.model.User">
       <!--index=""(可以省略)是设置参数的索引(0开始),是第几个 type可以不用写
            name就是构造函数的参数值,value就是赋的值
    -->
       <!--翻译constructor:构造函数-->
       <constructor-arg name="user_id" value="100" index="0" type="java.lang.Integer"/>
       <constructor-arg name="user_name" index="1">
          <value>悟空</value>  <!--上面是简写-->
          <!--设置空是<null/>-->
       </constructor-arg>
    </bean>

    ConstructorObjectTest.java

    /**
     * 测试在beans.xml中用构造函数实例化对象——普通值
     */
    @Test
    public void test02() {
       ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    
       User user = ac.getBean("user01",User.class);
       System.out.println(user);
    }

    4.构造函数实例化数组,list,set

    User.java

    public User(String user_name, Integer user_id, String[] hobbyArray, List<String> hobbyList, Set<String> hobbySet) {
       this.user_name = user_name;
       this.user_id = user_id;
       this.hobbyArray = hobbyArray;
       this.hobbyList = hobbyList;
       this.hobbySet = hobbySet;
    }

    beans.xml

    <!--构造函数实例化数组,list,set-->
    <bean id="user02" class="com.hs.model.User">
       <constructor-arg name="user_name" value="八戒" index="0"/>
       <constructor-arg name="user_id" value="200" index="1"/>
       <constructor-arg name="hobbyArray" index="2">
          <array>
             <value>篮球</value>
             <value>足球</value>
             <value>看书</value>
             <value>音乐</value>
          </array>
       </constructor-arg>
       <constructor-arg name="hobbyList">
          <list>
             <value>篮球</value>
             <value>足球</value>
             <value>看书</value>
             <value>音乐</value>
          </list>
       </constructor-arg>
       <constructor-arg name="hobbySet">
          <set>
             <value>篮球</value>
             <value>足球</value>
             <value>看书</value>
             <value>音乐</value>
          </set>
       </constructor-arg>
    </bean>

    ConstructorObjectTest.java

    /**
     * 测试在beans.xml中用构造函数实例化对象——数组,list,set
     */
    @Test
    public void test03() {
       ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    
       User user = ac.getBean("user02",User.class);
       System.out.println(user);
    }

    5.构造函数实例化Map和Properties

    User.java

    public User(Map<String, Object> map, Properties properties) {
       this.map = map;
       this.properties = properties;
    }

    beans.xml

    <!--构造函数实例化Map,Properties-->
    <bean id="user03" class="com.hs.model.User">
       <constructor-arg name="map">
          <map>
             <entry key="hs">
                <value>和尚</value>
             </entry>
             <!--缩写-->
             <entry key="name" value="悟空"/>
          </map>
       </constructor-arg>
       <constructor-arg name="properties">
          <props>
             <!--给Properties赋值-->
             <prop key="age">100</prop>
             <prop key="RuntimeExceiption">error</prop>
          </props>
       </constructor-arg>
    </bean>

    测试

    /**
     * 测试在beans.xml中用构造函数实例化对象——Map和Properties
     */
    @Test
    public void test04() {
       ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    
       User user = ac.getBean("user03",User.class);
       System.out.println(user);
    }

    6.初始化自定义类型

    Role.java

    package com.hs.model;
    
    public class Role {
    
       private String role_name;
    
       public Role() {
       }
    
       public Role(String role_name) {
          this.role_name = role_name;
       }
    
       public String getRole_name() {
          return role_name;
       }
    
       public void setRole_name(String role_name) {
          this.role_name = role_name;
       }
    
       @Override
       public String toString() {
          return "Role{" +
                "role_name='" + role_name + '\'' +
                '}';
       }
    }

    User.java

    private Role hsRole;    //这是自定义类型

    beans.xml

    <!--构造函数初始化自定义类型-->
    <bean id="user04" class="com.hs.model.User">
       <constructor-arg name="hsRole">
          <bean id="role1" class="com.hs.model.Role"/>
       </constructor-arg>
    </bean>

    测试

    /**
     * 自定义类型实例化,给User类中的Role类的变量,进行实例化操作
     */
    @Test
    public void test05() {
       ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    
       User user = ac.getBean("user04",User.class);
       System.out.println(user);
       //下面这个证明User类的那个bean Role role,范围只能在User里
       /*Role role1 = ac.getBean("role1", Role.class);
       System.out.println(role1);*/
    }

    7.构造函数实例化自定义类型

    Role.java

    public Role(String role_name) {
       this.role_name = role_name;
    }

    User.java

    public User(Role hsRole) {
       this.hsRole = hsRole;
    }

    beans.xml

    <!--构造函数实例化自定义类型-->
    <bean id="user05" class="com.hs.model.User">
       <constructor-arg name="hsRole">
          <bean class="com.hs.model.Role">
             <constructor-arg name="role_name" value="超级管理员"/>
          </bean>
       </constructor-arg>
    </bean>

    测试

    /**
         * 给自定义类型初始化数据
         */
        @Test
        public void test06() {
            ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    
            User user = ac.getBean("user05",User.class);
            System.out.println(user);
        }

    8.推荐引用方式——构造函数实例化自定义类型

    beans.xml

    <!--构造函数实例化自定义类型——推荐引用方式-->
    <bean id="user06" class="com.hs.model.User">
       <!--<constructor-arg name="hsRole">
          &lt;!&ndash;引用bean,下面简写&ndash;&gt;
          <ref bean="role2"/>
       </constructor-arg>-->
       <constructor-arg name="hsRole" ref="role2"/>
    </bean>
    <bean id="role2" class="com.hs.model.Role">
       <constructor-arg name="role_name" value="引用方式推荐"/>
    </bean>

    测试

    /**
     * 给自定义类型初始化数据——推荐引用方式
     */
    @Test
    public void test07() {
       ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    
       User user = ac.getBean("user06",User.class);
       System.out.println(user);
       Role role = ac.getBean("role2", Role.class);
       System.out.println(role);
    }

    9.构造函数实现接口回调,接口注入实现类(重点!!!)

    ITest.java

    package com.hs.model;
    
    public interface ITest {
    
       void print();
    }

    ITestImpl.java

    package com.hs.model;
    
    public class ITestImpl implements ITest {
    
       @Override
       public void print() {
          System.out.println("Hello Word!!");
       }
    }

    User.java

    private ITest hsTest;   //定义接口变量
    
    /**
     * 这里通过bean.xml构造函数初始化
     * 1.ITestImpl testImpl = new ITestImpl();
     * 2.hsTest = testImpl
     * 3.ITest hsTest = new ITestImpl();
     * 典型的接口回调嘛
     * @param hsTest
     */
    
    public User(ITest hsTest) {
       this.hsTest = hsTest;
    }

    beans.xml

    <!--实现接口回调,接口注入实现类-->
    <!-- 这里通过bean.xml构造函数初始化
     1.ITestImpl testImpl = new ITestImpl();
     2.hsTest = testImpl -->
    <bean id="user07" class="com.hs.model.User">
       <constructor-arg name="hsTest">
          <ref bean="testImpl"/>
       </constructor-arg>
    </bean>
    <!--ITestImpl testImpl = new ITestImpl();-->
    <bean id="testImpl" class="com.hs.model.ITestImpl"/>

    测试

    /**
     * 接口注入实现类,实现接口回调
     */
    @Test
    public void test08() {
       ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
    
       User user = ac.getBean("user07",User.class);
       user.getHsTest().print();
    }
    展开全文
  • 加自定义请求头前,用@CrossOrigin解决了跨域问题。也就是@RestController或者是@Controller前面加@CrossOrigin 在加自定义请求头后,又出现了跨域问题,用了Java笔记虾方法解决了。 这里需要说明下...
  • 通常我们对象Detail面板里看到变量属性都是对应C++中先声明变量,然后加一个UProperty变量前面,UE就会反射到蓝图面板上。 但是还有一种方法,是通过面板映射方式,Detail面板上映射自己想要...
  • //建立自己新建的类的对象my1 if(my1.exec()==QDialog::Accepted) //利用Accepted 信号判 断enterBtn 是否被按下 { w.show(); //如果被按下,显示主窗口 return a.exec(); //程序一直执行,直到主窗口 关闭 } else ...
  • 新增商品排序功能,由于商品是按添加日期进行排序的,对于添加较早的商品很难再调到前面显示,商品排序可以让任意的商品自由排序,可以方便的调用很早以前添加的商品置于首页或位于某些商品的前面显示。 三四、...
  • 可以用export关键字将内容给其他模块,最简单的例子中,可以将export放在任何变量、函数或声明的前面,以将它们从模块中导出。 useModule.js如下: //两种导出形式的区别: //(1)默认形式:不用任何修饰 //(2)...
  • 我们进行团队开发时,类的注释已经可以做到自定义了,详细看上篇文章《vs2017通过模块文件添加自定义注释》,而对于方法的注释,我们也需要完善一下,这里我们用到了“代码片断”插件,VS里有很多命令的缩写,如...
  • 一个主view(一个自定义view),主view中定义了统一paint、bitmap、canvas,以及子类中需要用到3个点downPoint,movePoint,upPoint。 其他子类(画直线view、画矩形view)都是继承这个主view...
  • 打开后,使用FllAddFoxCode()向智能感应库添加所有函数原型(需要VFP7以上),此库存所有函数使用VFP推荐命名规则,一般可以根据函数名和知能感应提示参数来推测参数及返回值。 开发环境可以使用FllHelp()...
  • 星号表示,其前面的括号“[]”内空格符或制表符,一行中出现0个或多个。 (6)选择“换行符”,插入“\n”,表示回车符。 ④、“替换为”组合框保持空,表示删除查找到内容。单击“替换”按钮逐个行删除空行,...
  • /usr/lib之类的目录下,c源程序里直接写#include 时,能直接去找到它们,VC里,同样的,最简单的方法就是将oSIP2源码包中的Include目录下的 osipparser2目录直接拷到我们的Windows下默认...
  • 这个项目完全按照高访问量互联网站进行设计,通过这个项目,学员不仅可以实战中巩固对前面学习ASP.Net、ADO.Net、WinForm等知识掌握,还可以掌握网站防黑、缓存、SEO、静态化、搜索引擎技术、AJAX等大型互联网...
  • 以此来创建DML执行计划,如果将DDL放在前面那么这种编译只需要以此就可以了。  合理使用索引: 根据实际查询需求来创建索引 尽量使用索引字段做查询条件 尽量避免对大数据量表进行全表扫描,可考虑新建索引 ...
  • 第十一篇 中间件

    2018-04-10 22:26:00
    我们在前面的课程中已经学会了给视图函数装饰器来判断是用户是否登录,把没有登录用户请求跳转到登录页面。我们通过给几个特定视图函数装饰器实现了这个需求。但是以后添加视图函数可能也需要加上装饰器,...
  • 程序因OOM强制关闭过嘛 你加在网络图片头疼嘛 有了组件 你将永久摆脱前面的问题 四 DbUtils 简单易用又出色ORM框架 真是谁用谁知道 直接轻松存储各种对象到sqlite数据库中 同时也能非常方便进行...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 123
精华内容 49
关键字:

在自定义类的前面需要加