代理
我们拿事务的实现来举例。首先，我们模拟一下事务，编写一个类
public class TransactionManager {
public void begin() {
System.out.println("开启事务");
}
public void commit() {
System.out.println("提交事务");
}
public void rollback() {
System.out.println("回滚事务");
}
}
没有代理
没有代理的事务实现方式 -装饰模式
可以在service实现类中开启事务，代码类似于如下
public class EmployeeServiceImplWapper implements IEmployeeService {
private EmployeeServiceImpl service;
private TransactionManager txManager = new TransactionManager();
public EmployeeServiceImplWapper(EmployeeServiceImpl service) {
this.service = service;
}
@Override
public void add() {
try {
txManager.begin();
service.add();
txManager.commit();
} catch (Exception e) {
e.printStackTrace();
txManager.rollback();
}
}
}
在每次增加一个方法的时候，都要添加事务，显得比较麻烦。基于责任分离的原则，service层的责任就是关注于逻辑，代码应当只关注于逻辑，只编写逻辑代码。
在调用service方法的时候，使用如下代理
public class App {
@Test
public void testExtends() throws Exception {
EmployeeServiceImpl empSer = new EmployeeServiceImpl();
IEmployeeService serviceWapper = new EmployeeServiceImplWapper(empSer);
serviceWapper.add();
}
}
至此，没有使用代理的事务实现方式的完成
这种方式是不安全的。因为调用者完全可以跳过EmployeeServiceImplWapper类，直接调用EmployeeServiceImpl的add方法，这样调用的方法就没有事务了。
代理的事务实现方式
静态代理
@Component
public class EmployeeServiceImplWapper implements IEmployeeService {
private EmployeeServiceImpl service;
private TransactionManager txManager = new TransactionManager();
public void setService(EmployeeServiceImpl service) {
this.service = service;
}
@Override
public void add() {
try {
txManager.begin();
service.add();
txManager.commit();
} catch (Exception e) {
e.printStackTrace();
txManager.rollback();
}
}
}
上述使用了spring的管理工具，service不再暴露在外。
静态代理的优点：
- 业务类只需要关注业务逻辑本身，保证了业务类的重用性。
静态代理的缺点：
- 代理对象的某个接口只服务于某一种类型的对象，也就是说每一个真实对象都得创建一个代理对象。
- 如果需要代理的方法很多，则要为每一种方法都进行代理处理。
- 如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
动态代理
@Component
public class TransactionManagerInvocationHandler implements InvocationHandler {
@Resource
private TransactionManager txManager;
@Resource
private EmployeeServiceImpl service;
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object obj = null;
try {
txManager.begin();
obj = method.invoke(service, args);
txManager.commit();
} catch (Exception e) {
e.printStackTrace();
txManager.rollback();
}
return obj;
}
public T getProxy() {
Object proxy = (IEmployeeService) Proxy.newProxyInstance(Thread
.currentThread().getContextClassLoader(),
new Class[] { IEmployeeService.class }, this);
return (T) proxy;
}
}
动态代理类是在程序运行期间由JVM通过反射等机制动态的生成的，所以不存在代理类的字节码文件。代理对象和真实对象的关系是在程序运行时候才确定的。
接口InvocationHandler的invoke方法简介：
Object proxy --> 生成的代理对象
Method method --> 代理对象调用的方法
Object[] args --> 代理对象调用的方法的参数
return obj --> 调用方法Method method返回的值
jdk动态代理总结：
JAVA动态代理是使用java.lang.reflect包中的Proxy类与InvocationHandler接口这两个来完成的。
要使用JDK动态代理，必须要定义接口。
JDK动态代理将会拦截所有pubic的方法（因为只能调用接口中定义的方法），这样即使在接口中增加了新的方法，不用修改代码也会被拦截。
如果只想拦截一部分方法，可以在invoke方法中对要执行的方法名进行判断。
第三方代理CGLIB
@Component
public class TransactionManagerEnhancerHandler implements InvocationHandler {
@Resource
private TransactionManager txManager;
@Resource
private EmployeeServiceImpl service;
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object obj = null;
try {
txManager.begin();
obj = method.invoke(service, args);
txManager.commit();
} catch (Exception e) {
e.printStackTrace();
txManager.rollback();
}
return obj;
}
public T getProxy() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(EmployeeServiceImpl.class);
enhancer.setCallback(this);
return (T) enhancer.create();
}
}
cglib对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
CGLIB动态代理总结：
- CGLIB可以生成目标类的子类，并重写父类非final修饰符的方法。
- 要求类不能是final的，要拦截的方法要是非final、非static、非private的。
- 动态代理的最小单位是类(所有类中的方法都会被处理)。
spring对代理的选择
当代理的类没有实现接口的时候，使用的代理方式是CGLIB。如果代理的类有实现的接口的时候，使用的代理方式就是jdk动态代理