Java中注解，反射注解，Bean工厂，动态代理

注解

注解的定义

//定义属性
@interface myAnnotation{
int age();
String name();
}

注解的使用

//注解的作用目标
 //一般用在类，方法，构造器，参数，局部变量，前
@MyAnno1
public class Demo1 {
    @MyAnno1
    private String name;
    
    @MyAnno1
    public Demo1() {
        
    }
    
    @MyAnno1
    public void fun1() {
        
    }
    
    public void fun2(@MyAnno1 String name) {
        @MyAnno1
        String username = "hello";
    }
}

//对于定义了属性的注解的使用
@MyAnnotation(age=32,name="sma")
public class demo{
}

注解属性的类型

只能是

/*
> 8种基本类型
    > String
    > Enum
    > Class
    > 注解类型
    > 以上类型的一维数组类型
*/

注解的额外内容

1.默认值

@interface MyAnno2 {
    int age() default 100;
    String name();
}

使用时，该属性可以不赋值。

2.value属性。

注解有一个属性名称可以叫value，使用注解是，可以省略value=

3.作用范围限定

在定义注解前加上，比如

//限定注解MyAnno1只能在类，方法和成员变量前使用
@Target(value={ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@interface MyAnno1 {
    
}

4保留策略

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnno1 {
    
}

枚举RetentionPolicy有SOURCE，CLASS，RUNTIME，分别说明注解会保留在其中。

注意：要反射注解，只有使用RUNTIME。

反射注解

//反射泛型
abstract  class A<T>{
public A(){
}
}


class B extentds A<String>{
}

// 现在在其他某处使用类B，B b=new B(),想知道父类泛型具体是什么类。
在A的构造函数加入如下代码，具体执行在new B()时进行

Class clazz = this.getClass();//得到子类的类型
Type type = clazz.getGenericSuperclass();//获取传递给父类参数化类型
ParameterizedType pType = (ParameterizedType) type;//它就是A<String>
Type[] types = pType.getActualTypeArguments();//它就是一个Class数组
Class c = (Class)types[0];//它就是String

//可以连在一起写成
//        Class c = (Class)((ParameterizedType)this.getClass()
//                .getGenericSuperclass()).getActualTypeArguments()[0];
//        
//        System.out.println(c.getName());

 反射注解

//对于类A和注解MyAnno1
@MyAnno1(name="A类", age=1, sex="男")
class A {
    @MyAnno1(name="fun1方法", age=2, sex="女")
    public void fun1() {
        
    }
}

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnno1 {
    String name();
    int age();
    String sex();
}

分别获取类和方法上的注解

//获取类A上的注解
/*
         * 1. 得到作用目标
         */
        Class<A> c = A.class;
        /*
         * 2. 获取指定类型的注解
         */
        MyAnno1 myAnno1 = c.getAnnotation(MyAnno1.class);
        System.out.println(myAnno1.name() + ", " 
                    + myAnno1.age() + ", " + myAnno1.sex());


//获取方法上的注解
/*
         * 1. 得到作用目标
         */
        Class<A> c = A.class;
        Method method = c.getMethod("fun1");
        
        
        /*
         * 2. 获取指定类型的注解
         */
        MyAnno1 myAnno1 = method.getAnnotation(MyAnno1.class);
        System.out.println(myAnno1.name() + ", " 
                    + myAnno1.age() + ", " + myAnno1.sex());

Bean工厂

先声明若干类和接口

//以下存在于多个文件
public class Teacher {
    private String tid;
    private String name;
.......................
//getter and setter
.....
}


public class Student {
    private String number;
    private String name;
    private int age;
    private String sex;
    private Teacher teacher;
    
    public Teacher getTeacher() {
        return teacher;
//getter and setter
.....
}

import cn.itcast.domain.Student;

public interface StudentDao {
    void add(Student stu);
    void update(Student stu);
}



public class StudentImpl implements StudentDao {

    @Override
    public void add(Student stu) {
        System.out.println("StudentImpl.add()");
    }

    @Override
    public void update(Student stu) { 
        System.out.println("StudentImpl.update()");
    }

}
public class StudentImpl2 implements StudentDao {

    @Override
    public void add(Student stu) {
        System.out.println("StudentImp2.add()");
    }

    @Override
    public void update(Student stu) { 
        System.out.println("StudentImp2.update()");
    }

}
public interface StudentService {
    void login();
}


public class StudentServiceImpl implements StudentService {
    private StudentDao studentDao = null;

    // 谁调用service方法，谁就需要先调用本方法，提供dao
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }

    public void login() {
        studentDao.add(null);
        studentDao.update(null);
    }
}

 然后在一个xml文件配置这些类的对象

<?xml version="1.0" encoding="UTF-8"?>

<beans>
    <bean id="stu1" className="cn.itcast.domain.Student">
        <property name="number" value="ITCAST_1001"/>
        <property name="name" value="zhangSan"/>
        <property name="age" value="29"/>
        <property name="sex" value="male"/>
        <property name="teacher" ref="t1"/><!-- ref的值必须是另一个been的id -->
    </bean>
    
    <bean id="stu2" className="cn.itcast.domain.Student">
        <property name="number" value="ITCAST_1002"/>
        <property name="name" value="wangWu"/>
        <property name="age" value="94"/>
        <property name="sex" value="female"/>
        <property name="teacher" ref="t1"/><!-- ref的值必须是另一个been的id -->
    </bean>
    
    <bean id="t1" className="cn.itcast.domain.Teacher">
        <property name="tid" value="TEACHER_2001" />
        <property name="name" value="liSi" />
        <property name="salary" value="123.456" />
    </bean>
    
    <bean id="stuDao" className="cn.itcast.dao.impl.StudentImpl2">
    </bean>
    
    <bean id="stuService" className="cn.itcast.service.impl.StudentServiceImpl">
        <property name="studentDao" ref="stuDao"/>
    </bean>
</beans>

在需要的时候，从bean.xml中生成对象并使用

BeanFactory bf = new BeanFactory("beans.xml");
Student s1 = (Student)bf.getBean("stu1");
StudentDao stuDao = (StudentDao)bf.getBean("stuDao");
stuDao.add(null);
stuDao.update(null);
StudentService service = (StudentService) bf.getBean("stuService");
service.login();

动态代理

目的：现在有若干个接口，要得到一个对象，这个对象实现了这些接口的方法。

思考；

1.这个对象的类名并不重要，我们可以用Object来表示，如果有个Object o这个满足要求的对象，我们可以将其转化成接口类型，

然后调用接口方法。

2.接口中的方法由谁来实现？

这里使用InvocationHandler接口，实现其invoke方法

public Object invoke(Object proxy,Method m,Object[] args){

//具体实现

 .....

}

这样我们调用我们接口中的方法其实就是调用了invoke里面的内容

其中Method就是接口中的Method，接口方法的参数会传入args中。

interface A {
    public void a();
    public void aa();
    public Object aaa(String s, int i);
}

interface B {
    public void b();
    public void bb();
}

@Test
    public void fun1() {
        /*
         * 三大参数
         * 1. ClassLoader
         * 方法需要动态生成一个类，这个类实现了A、B接口，然后创建这个类的对象！
         * 需要生成一个类，这个类也需要加载到方法区中，谁来加载，当然是ClassLoader！！！
         * 
         * 2. Class[] interfaces
         * 它是要实现的接口们
         * 
         * 3. InvocationHandler
         * 它是调用处理器
         * 敷衍它！
         * 
         * 代理对象的实现的所有接口中的方法，内容都是调用InvocationHandler的invoke()方法。
         */
        ClassLoader loader = this.getClass().getClassLoader();
        InvocationHandler h = new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                System.out.println("你好，动态代理！");
                if(args[0]!=null){
                    System.out.println(args[0]);
                }
                return "返回的字符串";
            }
        };
        // 使用三大参数创建代理对象！！！
        Object o = Proxy.newProxyInstance(loader, new Class[]{A.class, B.class}, h);
        // 强转成A和B类型，成功了！
        A a = (A) o;
        Object result = a.aaa("hello", 100);
        System.out.println(result);
    }

控制台输出

你好，动态代理！
hello
返回的字符串

 动态代理的应用1：增强

// 服务员
public interface Waiter {
    // 服务
    public void serve();
}
public class ManWaiter implements Waiter {
    public void serve() {
        System.out.println("服务中...");
    }
}
public class Demo2 {
    @Test
    public void fun1() {
        Waiter manWaiter = new ManWaiter();//目标对象
        /*
         * 给出三个参数，来创建方法，得到代理对象
         */
        ClassLoader loader = this.getClass().getClassLoader();
        Class[] interfaces = {Waiter.class};
        InvocationHandler h = new WaiterInvocationHandler(manWaiter);//参数manWaiter表示目标对象
        // 得到代理对象，代理对象就是在目标对象的基础上进行了增强的对象！
        Waiter waiterProxy = (Waiter)Proxy.newProxyInstance(loader, interfaces, h);
        
        waiterProxy.serve();//前面添加“您好”，　后面添加“再见”
    }
}

class WaiterInvocationHandler implements InvocationHandler {
    private Waiter waiter;//目标对象
    
    public WaiterInvocationHandler(Waiter waiter) {
        this.waiter = waiter;
    }
    
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("您好！");
        this.waiter.serve();//调用目标对象的目标方法
        System.out.println("再见！");
        return null;
    }
}

 例子2：增强

public interface Waiter {
    // 服务
    public void serve();
    
    public void shouQian();
}
public class ManWaiter implements Waiter {
    public void serve() {
        System.out.println("服务中...");
    }
    
    public void shouQian() {
        System.out.println("收钱！");
    }
}
public interface AfterAdvice {
    public void after();
}
public interface BeforeAdvice {
    public void before();
}


public class Demo3 {
    @Test
    public void fun1() {
        ProxyFactory factory = new ProxyFactory();//创建工厂
        factory.setTargetObject(new ManWaiter());//设置目标对象
        factory.setBeforeAdvice(new BeforeAdvice() {//设置前置增强
            public void before() {
                System.out.println("您好不好！");
            }
        });
        
        factory.setAfterAdvice(new AfterAdvice() {//设置后置增强
            public void after() {
                System.out.println("再见不见！");
            }
        });
        
        Waiter waiter = (Waiter)factory.createProxy();
        waiter.shouQian();
    }
    }

public class ProxyFactory {
    private Object targetObject;//目标对象
    private BeforeAdvice beforeAdvice;//前置增强
    private AfterAdvice afterAdvice;//后置增强
    
    
    /**
     * 用来生成代理对象
     * @return
     */
    public Object createProxy() {
        /*
         * 1. 给出三大参数
         */
        ClassLoader loader = this.getClass().getClassLoader();
        Class[] interfaces = targetObject.getClass().getInterfaces();
        InvocationHandler h = new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                /*
                 * 在调用代理对象的方法时会执行这里的内容
                 */
                // 执行前置增强
                if(beforeAdvice != null) {
                    beforeAdvice.before();
                }
                
                Object result = method.invoke(targetObject, args);//执行目标对象的目标方法
                // 执行后置增强
                if(afterAdvice != null) {
                    afterAdvice.after();
                }
                
                // 返回目标对象的返回值
                return result;
            }
        };
        /*
         * 2. 得到代理对象
         */
        Object proxyObject = Proxy.newProxyInstance(loader, interfaces, h);
        return proxyObject;
    }
    
    
    public Object getTargetObject() {
        return targetObject;
    }
    public void setTargetObject(Object targetObject) {
        this.targetObject = targetObject;
    }
    public BeforeAdvice getBeforeAdvice() {
        return beforeAdvice;
    }
    public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
        this.beforeAdvice = beforeAdvice;
    }
    public AfterAdvice getAfterAdvice() {
        return afterAdvice;
    }
    public void setAfterAdvice(AfterAdvice afterAdvice) {
        this.afterAdvice = afterAdvice;
    }
}