开发笔记:反射05动态代理

静态代理举例 :

特点&＃xff1a;代理类和被代理类在编译期间&＃xff0c;就确定下来了

接口

interface ClothFactory{
void produceCloth();
}


被代理类

class NikeClothFactory implements ClothFactory{
&＃64;Override
public void produceCloth() {
System.out.println("Nike工厂生产一批运动服");
}
}


代理类

class ProxyClothFactory implements ClothFactory{
private ClothFactory factory;//用被代理类对象进行实例化
public ProxyClothFactory(ClothFactory factory){
this.factory &＃61; factory;
}
&＃64;Override
public void produceCloth() {
System.out.println("代理工厂做一些准备工作");
factory.produceCloth();
System.out.println("代理工厂做一些后续的收尾工作");
}
}


测试

public class StaticProxyTest {
public static void main(String[] args) {
//创建被代理类的对象
ClothFactory nike &＃61; new NikeClothFactory();
//创建代理类的对象
ClothFactory proxyClothFactory &＃61; new ProxyClothFactory(nike);
proxyClothFactory.produceCloth();
}
}


要想实现动态代理&＃xff0c;需要解决的问题&＃xff1f;

问题一&＃xff1a;如何根据加载到内存中的被代理类&＃xff0c;动态的创建一个代理类及其对象。

问题二&＃xff1a;当通过代理类的对象调用方法a时&＃xff0c;如何动态的去调用被代理类中的同名方法a。

• 问题一 :通过bean工厂ProxyFactory
• 问题二&＃xff1a;通过反射获取代理对象,的方法对象 Method

jdk提供的相关ApI

• (package java.lang.reflect)

接口:

interface Human{
String getBelief();
void eat(String food);
}


被代理类

//被代理类
class SuperMan implements Human{
&＃64;Override
public String getBelief() {
return "I believe I can fly!";
}
&＃64;Override
public void eat(String food) {
System.out.println("我喜欢吃" &＃43; food);
}
}


扩展方法:

class HumanUtil{
public void method1(){
System.out.println("&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;通用方法一&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;");
}
public void method2(){
System.out.println("&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;通用方法二&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;");
}
}


bean代理工厂

调用此方法&＃xff0c;返回一个代理类的对象。解决问题

class ProxyFactory{
//调用此方法&＃xff0c;返回一个代理类的对象。解决问题一
public static Object getProxyInstance(Object obj){//obj:被代理类的对象
MyInvocationHandler handler &＃61; new MyInvocationHandler();
handler.bind(obj);
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
}
}


调用处理器 InvocationHandler

1. 当我们通过代理类的对象&＃xff0c;调用方法a时&＃xff0c;就会自动的调用如下的方法&＃xff1a;invoke()

2. 将被代理类要执行的方法a的功能就声明在invoke()中

• 实现InvocationHandler接口,重写invoke()方法

class MyInvocationHandler implements InvocationHandler{
private Object obj;//需要使用被代理类的对象进行赋值
public void bind(Object obj){
this.obj &＃61; obj;
}
//当我们通过代理类的对象&＃xff0c;调用方法a时&＃xff0c;就会自动的调用如下的方法&＃xff1a;invoke()
//将被代理类要执行的方法a的功能就声明在invoke()中
&＃64;Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
HumanUtil util &＃61; new HumanUtil();
util.method1();
//method:即为代理类对象调用的方法&＃xff0c;此方法也就作为了被代理类对象要调用的方法
//obj:被代理类的对象
Object returnValue &＃61; method.invoke(obj,args);
util.method2();
//上述方法的返回值就作为当前类中的invoke()的返回值。
return returnValue;
}
}


调用处理器 类比 AOP当中的切面对象

测试类:

1. 通过代理工厂创建代理类对象
2. 通过代理类对象调用方法时&＃xff0c;会自动的调用被代理类中同名的方法

public class ProxyTest {
public static void main(String[] args) {
SuperMan superMan &＃61; new SuperMan();
//proxyInstance:代理类的对象
Human proxyInstance &＃61; (Human) ProxyFactory.getProxyInstance(superMan);
//当通过代理类对象调用方法时&＃xff0c;会自动的调用被代理类中同名的方法
String belief &＃61; proxyInstance.getBelief();
System.out.println(belief);

proxyInstance.eat("火锅");
}
}


AOP 应用原理分析

Spring–03–AOP简介

Spring AOP底层基于代理机制实现功能扩展&＃xff1a;

• 假如目标对象(被代理对象)实现接口&＃xff0c;则底层可以采用JDK动态代理机制为目标对象创建代理对象&＃xff08;目标类和代理类会实现共同接口&＃xff09;。
• 假如目标对象(被代理对象)没有实现接口&＃xff0c;则底层可以采用CGLIB代理机制为目标对象创建代理对象&＃xff08;默认创建的代理类会继承目标对象类型&＃xff09;。

创建日志切面类对象 案例:

• 将此日志切面类作为核心业务增强&＃xff08;一个横切面对象&＃xff09;类&＃xff0c;用于输出业务执行时长&＃xff0c;其关键代码如下&＃xff1a;

package com.cy.pj.common.aspect;
&＃64;Aspect
&＃64;Slf4j
&＃64;Component
public class SysLogAspect {
&＃64;Pointcut("bean(sysUserServiceImpl)")
public void logPointCut() {}
&＃64;Around("logPointCut()")
public Object around(ProceedingJoinPoint jp) throws Throwable{
try {
log.info("start:{}"&＃43;System.currentTimeMillis());
Object result&＃61;jp.proceed();//最终会调用目标方法
log.info("after:{}"&＃43;System.currentTimeMillis());
return result;
}catch(Throwable e) {
log.error("after:{}",e.getMessage());
throw e;
}
}
}


解析:

1. 客户端向服务端发起一个请求,服务器端的Controller来处理这个请求.

2. Controller处理请求,假如需要对这个请求做一定的业务处理,他可能要调用业务层对象. controller调用xxxService接口.的时候,实际运行时,要给这个接口注入一个实现类的对象.
   (最开始的路线是,Controller去访问我们的xxxService接口,xxxService去访问具体的实现类xxxServiceImpl,实现类去访问具体的dao)

3. Controller运行时去访问我们的xxxService接口,service访问代理对象,(Controller是耦合于我们的service接口,其实注入的是我们代理对象,代理对象默认优先级高于目标对象,所以Controller运行时通过接口的引用访问代理对象)

4. 代理对象访问我们的切面,

5. 切面再调用我们的目标对象xxxServiceImpl,的方法,(jp.proceed())目标对象再访问我们的dao进行业务处理.