精华内容
下载资源
问答
  • 1.自定义注解 ```java @Retention(RetentionPolicy.RUNTIME) @Target({ ElementType.TYPE })//定义在类上必须是TYPE ,如果是方法上FIELD @Documented public @interface Cacheable { public String prefix() ...

    1.自定义注解

    
    ```java
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ ElementType.TYPE })//定义在类上必须是TYPE ,如果是属性上FIELD
    @Documented
    public @interface Cacheable {
    
        public String prefix() default "";
    
        public String key() default "";
    
        public int expire() default  1800;
    }
    
    
    2.类上注解
    
    ```java
    @Cacheable(prefix = "yang", key = "money")
    public class User {
        private String usernae;
    }
    

    3.测试

    
    ```java
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    import java.util.Map;
    
    public class TestMain {
        public static void main(String[] args) throws Exception {
            User user=new User();
            //获取注解上的值
            Cacheable annotation = user.getClass().getAnnotation(Cacheable.class);
            System.out.println(annotation.prefix()+"\t"+annotation.key()+"\t"+annotation.expire());
    
            //设置注解上的值
            InvocationHandler cacheable = Proxy.getInvocationHandler(annotation);//获取注解
            Field field = cacheable.getClass().getDeclaredField("memberValues");
            field.setAccessible(true);
            Map<String,Object> map= (Map<String, Object>) field.get(cacheable);
            map.put("prefix","jie");
            map.put("key","yang");
            map.put("expire",520);
            System.out.println(annotation.prefix()+"\t"+annotation.key()+"\t"+annotation.expire());
        }
    }
    
    
    如果是全局属性上,先获取属性,再获取属性上的注解
    
    
    展开全文
  • 反射修改类注解内容 1、获取注解类class对象 2、获取注解 3、反射动态代理注解 4、获取常量池中的Map,memberValues字段 5、设置字段可访问性 6、获取注解Map 7、修改注解中对应属性的值 package pers.yezi.test....

    反射修改类注解内容

    1、获取注解类class对象
    2、获取注解
    3、反射动态代理注解
    4、获取常量池中的Map,memberValues字段
    5、设置字段可访问性
    6、获取注解Map
    7、修改注解中对应属性的值

    package pers.yezi.test.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    import java.util.Map;
    
    /**
     * @ClassName : MyAnnotation
     * @Description : 注解测试
     * @Author : Yezi
     * @Date: 2020-07-06 15:20
     */
    @Retention(RetentionPolicy.RUNTIME) //运行时有效
    @Target(ElementType.TYPE) //描述类
    @interface Entity{
    	String value() default "";
    	boolean lazy() default false;
    
    }
    
    @Retention(RetentionPolicy.RUNTIME) //运行时有效
    @Target(ElementType.FIELD)  //描述属性
    @interface ID{
    	String value() default "";
    }
    
    @Entity("类注解")
    public class MyAnnotation {
    	@ID("属性注解")
    	private Integer number;
    
    	public Integer getNumber() {
    		return number;
    	}
    
    	public void setNumber(Integer number) {
    		this.number = number;
    	}
    
    	public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
    		//修改类注解内容
    		//1、获取类的字节码文件
    		Class<? extends MyAnnotation> aClass = new MyAnnotation().getClass();
    		//2、获取注解
    		Entity annotation = aClass.getDeclaredAnnotation(Entity.class);
    		//打印原始值
    		System.out.println(annotation.value());
    		if (annotation!=null){
    			//3、反射代理注解
    			InvocationHandler handler = Proxy.getInvocationHandler(annotation);
    			//4、通过动态代理获取常量池中的Map memberValues字段
    			Field field = handler.getClass().getDeclaredField("memberValues");
    			//5、设置可访问性
    			field.setAccessible(true);
    			//6、获取注解Entity的Map
    			Map o = (Map) field.get(handler);
    			//7、修改Entity注解中的值
    			o.put("value", "修改成功");
    		}
    		//打印修改值
    		System.out.println(annotation.value());
    	}
    }
    

    在这里插入图片描述

    反射修改属性注解内容

    1、获取注解类的字节码文件
    2、获取要修改注解的属性
    3、设置属性可访问性
    4、获取属性注解
    5、反射代理注解
    6、通过代理获取常量池中的Map,memberValues字段
    7、设置字段可访问性
    8、获取属性注解Map
    9、修改属性注解中的属性对应值

    package pers.yezi.test.annotation;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    import java.util.Map;
    /**
     * @ClassName : MyAnnotation
     * @Description : 注解测试
     * @Author : Yezi
     * @Date: 2020-07-06 15:20
     */
    @Retention(RetentionPolicy.RUNTIME) //运行时有效
    @Target(ElementType.TYPE) //描述类
    @interface Entity{
    	String value() default "";
    	boolean lazy() default false;
    
    }
    @Retention(RetentionPolicy.RUNTIME) //运行时有效
    @Target(ElementType.FIELD)  //描述属性
    @interface ID{
    	String value() default "";
    }
    @Entity("类注解")
    public class MyAnnotation {
    	@ID("属性注解")
    	private Integer number;
    	public Integer getNumber() {
    		return number;
    	}
    	public void setNumber(Integer number) {
    		this.number = number;
    	}
    	public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
    		//反射修改属性注解内容
    		//1、获取类的字节码文件
    		Class<? extends MyAnnotation> aClass = new MyAnnotation().getClass();
    		//2、获取要修改注解的属性
    		Field num = aClass.getDeclaredField("number");
    		//3、设置属性可访问属性
    		num.setAccessible(true);
    		//4、获取属性注解
    		ID annotation = num.getAnnotation(ID.class);
    		//打印原始值
    		System.out.println(annotation.value());
    		if (annotation!=null){
    			//5、反射代理注解
    			InvocationHandler handler = Proxy.getInvocationHandler(annotation);
    			//6、通过动态代理获取常量池中的Map memberValues字段
    			Field field = handler.getClass().getDeclaredField("memberValues");
    			//7、设置字段可访问性
    			field.setAccessible(true);
    			//8、获取属性注解ID的Map
    			Map o = (Map) field.get(handler);
    			//9、修改属性注解ID的属性值
    			o.put("value", "修改成功");
    		}
    		//打印修改值
    		System.out.println(annotation.value());
    

    在这里插入图片描述
    参考文档
    1、https://www.php.cn/java/base/451648.html
    2、https://blog.csdn.net/luo_yu_1106/article/details/92574493

    展开全文
  • 注解内容01_元注解概述1.1 概述1.2 常用的元注解1.3 元注解使用02_自定义注解@MyTest2.1 需求2.2 开发步骤2.3 代码实现03_自定义注解@JDBCInfo3.1 需求3.2 开发步骤3.3 代码实现04_反射、注解、设计模式初级版...

    01_元注解概述

    1.1 概述

    • 作用在自定义注解上,规定自定义注解的作用区域、存活策略!

    1.2 常用的元注解

    • @Target
      • 规定自定义注解的作用区域
        TYPE:类、接口、注解、枚举
        FIELD:成员你变量
        METHOD:成员方法
        PARAMETER:形参
        CONSTRUCTOR:构造器
        LOCAL_VARIABLE:局部变量
        ANNOTATION_TYPE:注解类型
        PACKAGE:包
    • @Retention
      • 规定自定义注解的存活策略
        SOURCE : 仅存活在源码
        CLASS : 存活在编译期
        RUNTIME : 存活在运行时

    1.3 元注解使用

    • @Target
      • 定义
    @Target(value = {
                  ElementType.TYPE ,
                  ElementType.FIELD ,
                  ElementType.METHOD ,
                  ElementType.PARAMETER ,
                  ElementType.LOCAL_VARIABLE }
                  )
          public @interface MyAnnotation01 {
          
              String value() default "hello annotation";
          
          }
    
    • 使用
    		 @MyAnnotation01
         	 public class Demo01 {
          
              @MyAnnotation01
              private int num = 1;
          
              @MyAnnotation01
              public static void main(@MyAnnotation01 String[] args) {
          
                  @MyAnnotation01
                  int num = 1;
              }
          
          }
    
    • @Retention
      • 定义
    		 @Retention(RetentionPolicy.RUNTIME)
         	 public @interface MyAnnotation01 {
          
              String value() default "hello annotation";
          
         	 }
    
    • 一般情况下,注解存活策略是RUNTIME,什么原因?
      • 注解要起作用,必须结合反射使用,而反射是在程序运行时(RUNTIME)执行!

    02_自定义注解@MyTest

    2.1 需求

    • 测试类中,方法上如果使用了@MyTest注解,该方法就会执行!

    2.2 开发步骤

    • 自定义注解@MyTest
    • 在测试类Test01上使用@MyTest
    • 让@MyTest注解生效
      • 获取到Test01类对应的Class对象
      • 获取Test01类中的所有方法
      • 判断方法上是否有@MyTest注解
        • 如果有,就将该方法执行
        • 如果没有,就不处理

    2.3 代码实现

    • @MyTest注解
      • @MyTest的存活策略必须是RUNTIME
    	 @Retention(RetentionPolicy.RUNTIME)
          public @interface MyTest {
              String value() default "";
          }
    
    • Test01测试类

      public class Test01 {
      
        @Test
        public void test01(){
            System.out.println("test01");
        }
      
        @MyTest
        public void test02(){
            System.out.println("test02");
        }
      
        @MyTest
        public void test03(){
            System.out.println("test03");
        }
      
        public void test04(){
            System.out.println("test04");
        }
      

      }

    • demo类

      public class Demo02 {
      
        public static void main(String[] args) {
            //使用反射,扫描Test01类里面有哪些方法有@MyTest注解
            //如果有@MyTest注解,就将起执行
            //如果没有@MyTest注解,不做任何处理
      
            //1,获取Test01类对应的Class对象
            Class<Test01> clazz = Test01.class;
            //2,获取Test01类下所有的方法对象
            Method[] methods = clazz.getMethods();
            //stream流 lambda表达式
            Arrays.stream(methods).forEach(method -> {
                //method就是单个方法对象
                //3,判断方法上是否有@MyTest注解
                boolean present = method.isAnnotationPresent(MyTest.class);
                if (present) {
                    //方法上有@MyTest注解,执行方法
                    try {
                        method.invoke(clazz.newInstance());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } else {
                    //方法上没有@MyTest注解
                }
            });
      
        }
      

      }

    03_自定义注解@JDBCInfo

    3.1 需求

    • 使用注解@JDBCInfo替代jdbc.properties配置文件

    3.2 开发步骤

    • 自定义注解@JDBCInfo
    • 在JDBCUtils工具类上使用@JDBCInfo
    • 在JDBCUtils工具类中静态代码块中,获取@JDBCInfo注解上的属性,并给JDBCUtils工具类中成员变量赋值

    3.3 代码实现

    • 自定义注解@JDBCInfo
      @Target(ElementType.TYPE)
      @Retention(RetentionPolicy.RUNTIME)
      public @interface JDBCInfo {

        String driverClass() default "com.mysql.jdbc.Driver";
        String jdbcUrl() default "jdbc:mysql://localhost:3306/day53";
        String user() default "root";
        String password() default "root123";
      

      }

    • 在JDBCUtils工具类上使用@JDBCInfo

      • 反射读取注解@JDBCInfo中的内容
    		  @JDBCInfo(password = "root")
         	  public class JDBCUtils {
          
              private static final String DRIVERCLASS ;
              private static final String JDBCURL;
              private static final String USER;
              private static final String PASSWORD;
          
              static {
                  Class<JDBCUtils> clazz = JDBCUtils.class;
                  boolean present = clazz.isAnnotationPresent(JDBCInfo.class);
                  if (present) {
                      //JDBCUtils类上有@JDBCInfo注解,获取该注解
                      JDBCInfo jdbcInfo = clazz.getAnnotation(JDBCInfo.class);
                      //从@JDBCInfo注解获取driverClass、jdbcUrl、user、password属性值
                      DRIVERCLASS = jdbcInfo.driverClass();
                      JDBCURL = jdbcInfo.jdbcUrl();
                      USER = jdbcInfo.user();
                      PASSWORD = jdbcInfo.password();
                  } else {
                      //JDBCUtils类上没有@JDBCInfo注解,从properties文件
                      DRIVERCLASS = "";
                      JDBCURL = "";
                      USER = "";
                      PASSWORD = "";
                  }
              }
          }
          
    

    04_反射、注解、设计模式初级版

    4.1 开发步骤

    • 自定义注解@SystemLog
      • className
      • methodName
    • 定义一个UserDao接口,且在该接口使用注解@SystemLog
    • 编写装饰者设计模式
      • 获取UserDao实现子类的Class对象
      • 获取UserDao接口的Class对象
      • 获取UserDao接口中的方法对象

    4.2 代码实现

    • 自定义注解@SystemLog
      • 注解存活策略:RUNTIME
    		@Retention(RetentionPolicy.RUNTIME)
            public @interface SystemLog {
            
                String className();//记录类名
                String methodName();//记录方法名
            
            }
    
    • 定义一个UserDao接口,且在该接口使用注解@SystemLog
      • 设置@SystemLog中className属性、methodName属性
     		public interface UserDao {
            
                @SystemLog(className = "com.qfedu.dao.UserDao" , methodName = "addUser")
                void addUser() throws Exception;
            
                void deleteUser() throws Exception;
            
                @SystemLog(className = "com.qfedu.dao.UserDao" , methodName = "updateUser")
                void updateUser() throws Exception;
            
            }
    
    • 编写装饰者设计模式
     public class UserDaoWrapper implements UserDao{
            
                private UserDao userDao;
            
                public UserDaoWrapper(UserDao userDao) {
                    this.userDao = userDao;
                }
            
                @Override
                public void addUser() throws Exception {
                    userDao.addUser();
                    printLog("addUser");
                }
            
                @Override
                public void deleteUser() throws Exception {
                    userDao.deleteUser();
                    printLog("deleteUser");
                }
            
                @Override
                public void updateUser() throws Exception {
                    userDao.updateUser();
                    printLog("updateUser");
                }
            
                /**
                 * 日志记录
                 * @param runMethodName
                 */
                private void printLog(String runMethodName) throws Exception {
                    //判断接口上对应的方法中是否有@SystemLog注解
                    //获取UserDao接口实现子类的Class对象
                    Class<? extends UserDao> sonClazz = userDao.getClass();
                    //获取UserDao接口的Class对象
                    Class<?>[] interfaces = sonClazz.getInterfaces();
                    Class<?> fatherClazz = interfaces[0];
                    //获取接口中对应的方法对象(addUser方法)
                    Method method = fatherClazz.getMethod(runMethodName);
                    if (null !=  method) {
                        //判断方法上是否有@SystemLog注解
                        boolean present = method.isAnnotationPresent(SystemLog.class);
                        if (present) {
                            //方法有@SystemLog注解,打印日志
                            SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
                            Date currentDate = new Date();
                            String currentTimeStr = format.format(currentDate);
                            SystemLog systemLog = method.getAnnotation(SystemLog.class);
                            String className = systemLog.className();
                            String methodName = systemLog.methodName();
                            System.out.println(currentTimeStr + " --- " + className + "类中 ---" + methodName + "()方法 --- 运行了");
                        }
                    }
            
                }
            }
    

    4.3 存在的问题

    • 由装饰者设计模式的弊端导致每个方法中都需要调用printLog方法

    05_反射、注解、设计模式优化版

    5.1 开发步骤

    • 自定义注解@SystemLog
      • className
      • methodName
    • 定义一个UserDao接口,且在该接口使用注解@SystemLog
    • 动态代理
      • 获取UserDao接口中的方法对象

    5.2 代码实现

    • 自定义注解@SystemLog
     		@Retention(RetentionPolicy.RUNTIME)
            public @interface SystemLog {
            
                String className();//记录类名
                String methodName();//记录方法名
            
            }
    
    • 定义一个UserDao接口,且在该接口使用注解@SystemLog
      • 设置@SystemLog中className属性、methodName属性
    	    public interface UserDao {
            
                @SystemLog(className = "com.qfedu.dao.UserDao" , methodName = "addUser")
                void addUser() throws Exception;
            
                void deleteUser() throws Exception;
            
                @SystemLog(className = "com.qfedu.dao.UserDao" , methodName = "updateUser")
                void updateUser() throws Exception;
            
            }
    
    • 动态代理
      				UserDao userDao = new UserDaoImpl();
                    UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(
                            userDao.getClass().getClassLoader(),
                            userDao.getClass().getInterfaces(),
                            new InvocationHandler() {
                                @Override
                                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                    //获取到接口中方法对象 , 比如 : UserDao接口中addUser方法
                                    //之前
                                    //先获取实现子类的Class对象
                                    //再获取到接口的Class对象
                                    //再获取到接口中的方法对象
                                    //现在
                                    //再获取到接口的Class对象  -- userDao.getClass().getInterfaces(),
                                    //再获取到接口中的方法对象  --  Method method
                                    //method : 就是接口中的方法对象
                                    Object returnValue = null;
                                    if (null != method) {
                                        boolean present = method.isAnnotationPresent(SystemLog.class);
                                        if (present) {
                                            //如果有@SystemLog注解 , 执行原有功能 ,  打印日志
                                            returnValue = method.invoke(userDao, args);
                                            String currentTimeStr = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss")
                                                    .format(new Date());
                                            SystemLog systemLog = method.getAnnotation(SystemLog.class);
                                            String className = systemLog.className();
                                            String methodName = systemLog.methodName();
                                            System.out.println(currentTimeStr + " --- " + className + "类中 ---" + methodName + "()方法 --- 运行了");
                                        } else {
                                            //如果没有@SystemLog注解, 执行原有功能, 不打印日志
                                            returnValue = method.invoke(userDao, args);
                                        }
                                    }
            
                                    return returnValue;
                                }
                            });
            
                    userDaoProxy.addUser();
        
    
    
    展开全文
  • @webServlet:代替web.xml的文件内容 注解作用:可以代替配置文件 注解:主要是给JVM查看,具有一定的功能作用。注解是给程序员进行提示使用。 关于配置文件与注解开发的优缺点: 优点:开发效率高,成本低。 缺点...

    一.什么是注解,注解作用

    注解就是符合一定格式的语法 @xxxx
    如:

    • @override :重写父类的方法
    • @Test:测试模块
    • @webServlet:代替web.xml的文件内容

    注解作用:可以代替配置文件
    注解:主要是给JVM查看,具有一定的功能作用。注解是给程序员进行提示使用。

    关于配置文件与注解开发的优缺点:

    • 优点:开发效率高,成本低。
    • 缺点:耦合性大并且不利于后期维护。

    例如我们在使用@webServlet的时候,会在源代码中修改文件的路径位置。然而web.xml就不要使用编译器打开源码进行修改。我们只需要打开响应xml文件即可。

    二.JDK5提供的注解

    • @Override:告知编译器此方法是覆盖父类的。如果方法名或方法未实现会报错
    • @Deprecated:标注过时
    • @SuppressWarnings:压制警告,可以压制不加泛型,或者压制未使用。或者@SuppressWarnings(“all”),表示压制所有。

    不同的注解只能在不同的位置使用(方法上、字段上、类上)

    三.自定义注解

    需要掌握三个方面的内容,

    • 编写一个自定义的注解
    • 使用注解
    • 解析注解——使用反射知识

    3.1如何编写一个自定义的注解

    • 关键字:@interface
    • 注解的属性的写法:返回值 名称();

    注意:如果属性的名字是value,并且注解的属性值有一个,那么在使用注解时可以省略value

    • 注解属性类型只能是以下几种
      1.基本类型
      2.String
      3.枚举类型
      4.注解类型
      5.Class类型
      6.以上类型的一维数组类型

    案例:

    public @interface first{
    	//String name();
    	//int age default 28;
    	String [] value()//使用注解的话只需要书写@first("a","b")即可
    }
    

    3.2使用注解

    创建一个类,或者方法,或者一个字段上

    案例:

    当注解中使用String name(),我们需要在此使用第一个注解
    @first(name ="张三")//————————第一个注解
    
    当注解中使用String [] value(),我们可以省略他的属性名称
    @first({"a","b","c"})//——————第二个注解
    public void show(){
    
    }
    

    3.3解析使用了注解的类

    我们查看注解的源码会发现注解上面仍有注解,以下为注解的源码。以此引入元注解的概念

    在这里插入图片描述 元注解:代表修饰注解的注解,作用:限制定义的注解的特性

    • @Retention
      • SOURCE: 注解在源码级别可见
      • CLASS:注解在字节码文件级别可见
      • RUNTIME:注解在整个运行阶段都可见
    • @Target
      代表注解修饰的范围:类上使用,方法上使用,字段上使用
      • FIELD:字段上可用此注解
      • METHOD:方法上可以用此注解
      • TYPE:类/接口上可以使用此注解
        在这里插入图片描述所以,我们
        注意:要想解析使用了注解的类 , 那么该注解的Retention必须设置成Runtime

    案例:(目的是解析注解)

    第一步:先自己写一个注解

    @Target({ElementType.METHOD,ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)  //必须设置到Runtime级别,才能进行获取
    public @interface MyAnno {
    
    	//注解的属性
    	String name();
    	
    	int age() default 28;
    	
    }
    

    第二步:使用自己书写的注解

    @MyAnno(name = "zhangsan")//在类上使用
    public class MyAnnoTest {
    	
    	@SuppressWarnings("all")
    	@MyAnno(name = "zhangsan")//在方法中使用
    	public void show(String str){
    		System.out.println("show running...");
    	}
    	
    }
    

    第三步:做测试解析自己的注解

    public class MyAnnoParser {
    
    	public static void main(String[] args) throws NoSuchMethodException, SecurityException {
    		
    		//解析show方法上面的@MyAnno
    		//直接的目的是 获得show方法上的@MyAnno中的参数
    		
    		//获得show方法的字节码对象
    		Class clazz = MyAnnoTest.class;
    		Method method = clazz.getMethod("show", String.class);
    		//获得show方法上的@MyAnno
    		MyAnno annotation = method.getAnnotation(MyAnno.class);
    		//获得@MyAnno上的属性值
    		System.out.println(annotation.name());//zhangsan
    		System.out.println(annotation.age());//28
    		
    		//根据业务需求写逻辑代码
    		//若需要获得多个注解的方法
    		Method[] methods= clazz.getMethods();
    		if(methods!=null){
    			//获得注解使用了@xxx的方法
    			for(Method method:methods){
    				//判断该方法是否使用了某注解的方法
    		boolean	anotationPresent = method.isAnnotationPresent(MyAnno.class);
    				if(anotationPresent){
    					//该方法使用MyTest注解
    				method.invoke(clazz.newInstance(),null)//输入的参数
    				}
    			}
    		}
    	}
    	
    }
    
    展开全文
  • 注解的基本内容

    2020-06-25 14:18:20
    注解标注的内容,表示已过时 @SuppressWarnings 会将出现警告的地方压制,一般传递参数all,如SuppressWarnings(“all”) 元注解 @target 表示注解可以用在那些地方,参数有: ElementType.TYPE:表明作用在类、...
  • 有关注解内容01_注解介绍1.1 概念1.2 特点1.3 作用02_java内置注解2.1 @Overirde2.2 @Deprecated2.3 @SuppressWarings2.3.1 value : 注解所压制的警告的类型03_注解分类04_自定义注解4.1 格式4.2 基本使用4.3 注意...
  • #自定义一个注解 //@Target 定义该注解的作用对象 即作用与类上,方法上,成员变量上,构造方法上等。。。 // ElementType.TYPE/METHOD/FIELD… //@Retention定义该注解的生命周期,即存活时间 SOURCE ,CLASS.RUNTIME ...
  • 注解

    2020-10-10 10:15:40
    在生成类文件时,注解可以被嵌入到字节码文件中,JVM可以保留注解内容,在运行时读取注解内容。 内置注解 Java提供了七个内置的注解 @override 重写 @Deprecated 废弃 @SupressWarning 抑制警告 // 在...
  • 自定义的注解类: import java.lang.annotation.*; @Retention(RetentionPolicy.RUNTIME) //注解的生命周期保存RUNTIME时 @Target({ElementType.METHOD,ElementType.TYPE})//注解使用的范围(可以是方法,也...
  • } /** * 获取table中的columns和类中的字段集合(包括表名前提model配置@Table注解注解包含name属性) * * @param clazz * @return */ public static TableClassBean getTableClassBean(Class clazz) { List list =...
  • 注解和maven

    2021-02-24 19:55:01
    今日内容注解常见的内置注解自定义注解使用注解(重点)元注解maven使用mavenmaven仓库配置settings.xml文件maven工程的目录结构Maven依赖管理 注解 常见的内置注解 @Override 重写 @Deprecated 过时 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,320
精华内容 4,528
关键字:

内容注解