Spring(四)

AOP
1 代理模式
代理模式是常用的Java设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。
代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现功能，而是通过调用委托类的对象的相关方法，
来提供特定的功能。

   IUserServie(){
   	void login(String u,String p);
   	void register(User user);
   }

   public class UserService implements IUserServie{

   	public void login(String u,String p){
   		开启事务
   		记录操作日志
   		//登录的业务逻辑代码
   		提交事务
   	}
   	public void register(User user){
   		[开始事务
   		记录操作日志]

   		//注册的业务逻辑代码


   		[提交事务]
   	}
   }
   //请代理:使用委托类的操作代码，实现同样的接口

   public UserServiceProxy implements IUserServie(){
   	private IUserService userService;
   	public UserServiceProxy(IUserService userService){
   		this.userService = userService;
   	}

   	public void login(String u,String p){
   		开启事务
   		记录操作日志

   		userService.login(String u,String p);
   		提交事务
   	}
   	public void register(User user){
   		[开始事务
   		记录操作日志]


   		userService.register(User user);
   		[提交事务]
   	}
   }


   main(){
   	//创建委托类
   	IUserService us = new UserService();
   	//创建代理类
   	IUserService usProxy = new UserServiceProxy(us);
   	usProxy.login();
   	usProxy.register();

   }

注意:
委托类对象就是我们后面说到的 目标对象(需要【被】代理的对象)
代理类对象就是我们后面说到的 代理对象(目标对象就是需要这个对象做为代理)
按照代理类的创建时期，代理类可分为两种。
静态代理类：
由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理类：
在程序运行时，运用反射机制或字节码技术动态创建而成。

2 静态代理
例如:
接口：HelloService
委托类：HelloServiceImpl
代理类：HelloServiceProxy

public interface HelloService{
	  public String echo(String msg);
	  public Date getTime();
	}

	public class HelloServiceImpl implements HelloService{
	  public String echo(String msg){
	    return "echo:"+msg;
	  }
	  public Date getTime(){
	   return new Date();
	  }
	}

	public class HelloServiceProxy implements HelloService{
	  private HelloService helloService; //表示被代理的HelloService 实例
	  public HelloServiceProxy(HelloService helloService){
	    this.helloService=helloService;
	  }
	  public void setHelloServiceProxy(HelloService helloService){
	     this.helloService=helloService;
	  }
	  public String echo(String msg){
	    System.out.println("before calling echo()"); //目标方法调前处理
	    //调用委托类对象的方法(也就是目标对象方法/被代理对象方法)
	    //这个方法才是我们真正要执行的方法
	    String result=helloService.echo(msg);
	    System.out.println("after calling echo()"); //目标方法调用后处理
	    return result;
	  }
	  public Date getTime(){
	    System.out.println("before calling getTime()"); //目标方法调前处理

	    //调用委托类对象的方法(也就是目标对象方法/被代理对象方法)
	    //这个方法才是我们真正要执行的方法
	    Date date=helloService.getTime();

	    System.out.println("after calling getTime()"); //目标方法调用后处理
	    return date;
	   }
	}

	main:
	   HelloService helloService=new HelloServiceImpl();
	   HelloService helloServiceProxy=new HelloServiceProxy(helloService);
	   System.out.println(helloServiceProxy.echo("hello"));

3 动态代理
与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，
而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包下面的Proxy类和InvocationHandler 接口提供了生成
动态代理类的能力。
JDK的动态代理：实现同样的接口,能被重写的
不写代理类，代理类由程序运行时动态生成
java反射生成实现了同样接口的代理类
Proxy,InvocationHandler
例子：

 接口:
    public interface IStudentService {

		void save(Student s);

		void delete(long id);

		Student find(long id);

    }

    实现类
    public class StudentServiceImpl implements IStudentService {
		public void delete(long id) {
			// 记录日志
			System.out.println("student is deleted...");
		}

		public Student find(long id) {
			// 记录日志
			System.out.println("student is found...");
			return null;
		}

		public void save(Student s) {
			// 记录日志
			System.out.println("student is saved...");
		}
    }

    日志类:
    public class StudentLogger {
		public void log(String msg){
			System.out.println("log: "+msg);
		}
    }
 处理器
    //InvocationHandler接口的实现类,java的动态代理中需要使用
    public class MyHandler implements InvocationHandler {
	//目标对象
		private Object target;
		private StudentLogger logger = new StudentLogger();

		public MyHandler() {
		}

		public MyHandler(Object target) {
			this.target = target;
		}

		// 参数1 将来所产生的代理对象 Proxy4$
		// 参数2 将来需要调用到的目标对象里面真正的那个方法的镜像
		// 参数3 将来调用方法的时候所传的参数
		public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
			// 获得将来所调用方法的名字
			String methodName = m.getName();
			// 用日志记录输出一下
			logger.log(methodName + " is invoked...");
			// 用反射的方式去调用将来需要真正调用的方法.
			Object o = m.invoke(target, args);

			return o;
		}
		get/set
		....
    }

    main:
		//目标对象
		//service是我们的目标对象。
		//我们要给目标对象产生代理对象。
		//目标对象service只能单独执行delete方法。
		//但是我们需要的是:先执行log日志方法再执行delete方法。
		//目标对象service做不到这个要求,所以我们要给目标对象service
		//生成一个代理对象去完成这俩个操作.


		//怎么给目标对象生成代理对象:
		//JDK动态代理的方式

		//获得目标对象的Class对象
		Class c = service.getClass();
		//获得目标对象的类加载器对象
		ClassLoader classLoader = c.getClassLoader();

		//获得目标对象所实现的所有接口
		Class[] interfaces = c.getInterfaces();

		//获得一个InvocationHandler接口的实现类对象,并把目标对象传进去
		InvocationHandler h =
				new MyHandler(service);

		//参数1 目标对象的类加载器对象
		//参数2 目标对象所实现的所有接口. Class类型数组
		//参数3 InvocationHandler接口的实现类对象
		IStudentService proxy =
			(IStudentService)Proxy.newProxyInstance
			(classLoader, interfaces, h);
		//这里的proxy是一个实现了IStudentService接口动态生成的代理类的对象
		proxy.delete();

4 CGLib代理
JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为目标对象创建一个子类对象，并在子类对象中拦截所有父类方法的调用，然后在方法调用前后调用后都可以加入自己想要执行的代码。JDK动态代理与CGLib动态代理都是Spring AOP的采用的代理方式。

需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类

简单的实现：
这是一个需要被代理的类，也就是父类，通过字节码技术创建这个类的子类，实现动态代理。

  public class SayHello {
	 public void say(){
	     System.out.println("hello everyone");
	 }
   }

注意:在cglib方式中,目标对象作为父类,代理对象作为目标对象动态生成的子类对象

该类CglibProxy实现了动态创建一个类的子类的方法(cglib给一个类生成代理对象的方式)
getProxy(SuperClass.class)方法通过参数即父类的class对象，创建出它的一个子类对象,也就是cglib方式的代理对象
intercept()方法拦截所有目标类方法的调用，
obj表示将来生成的代理对象，
method为目标类中方法的反射对象，args为方法的动态入参，
mproxy为代理类(子类)中方法的反射对象。
mproxy.invokeSuper(obj, args)通过代理类调用目标对象(父类)中的方法。

public class CglibProxy implements MethodInterceptor{

	 public Object getProxy(Class clazz){
	     Enhancer enhancer = new Enhancer();
	     //设置谁是父类
	     enhancer.setSuperclass(clazz);
	     enhancer.setCallback(this);
	     //通过字节码技术动态创建子类实例
	     return enhancer.create();
	 }

	 //实现MethodInterceptor接口方法
	 public Object intercept(Object obj, Method method, Object[] args,
	     MethodProxy mproxy) throws Throwable {
	     System.out.println("前置代理");
	     //通过代理类调用父类中的方法
	     Object result = mproxy.invokeSuper(obj, args);//调用父类中的方法
	     System.out.println("后置代理");
	     return result;
	 }
   }


   main:
      CglibProxy proxy = new CglibProxy();
      //通过生成子类的方式创建代理类
      SayHello proxyImp = (SayHello)proxy.getProxy(SayHello.class);
      proxyImp.say();

输出结果：
前置代理
hello everyone
后置代理
5 Spring实现AOP(Aspect Oriented Programming)是依赖JDK动态代理和CGLIB代理(不同情况spring会自己选择一种方式)。
JDK动态代理和CGLIB代理的对比:
JDK动态代理：其代理对象必须是某个接口的实现，它是通过在运行期间创建一个接口的实现类来完成对目标对象的代理。
CGLIB代理：实现原理类似于JDK动态代理，只是它在运行期间生成的代理对象是针对目标类扩展的子类。CGLIB是高效的代码生成包，底层是依靠ASM（开源的java字节码编辑类库）操作字节码实现的。

所以spring会有以下俩种选择动态代理实现方式的情况:
 *如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
 *如果目标对象没有实现了接口，spring会使用CGLIB的库来实现代理
spring会自动在JDK动态代理和CGLIB之间自动选择;