静态代理
特点：
- 目标对象必须要实现接口
- 代理对象，要实现与目标对象一样的接口
*需求： *
UserDao.java dao接口
UserDaoImpl.java dao实现 （目标对象）
void save(); // 保存实现
UserDaoProxy.java dao代理类，对UserDao中功能进行扩展！（代理对象）
App
缺点：
- 代理对象，需要依赖目标对象的接口！如果接口功能变化，目标对象变化，会引入代理对象的变化!
- 对每一个目标对象，都要分别写一个代理类，麻烦！(不过可用代理工厂)
类：
public interface UserDao {
public void save();
}
public class UserDaoImpl implements UserDao {
public void save(){
System.out.println("正在存储");
}
}
public class UserDaoProxy implements UserDao{
private UserDao userDao = new UserDaoImpl();
public void save(){
System.out.println("开启事务......");
userDao.save();
System.out.println("提交事务......");
}
}
public class App {
@Test
public void test(){
UserDao proxy = new UserDaoProxy();
proxy.save();
}
}
动态代理
- 通常说的动态代理，就是指jdk代理!因为是通过jdk的api在运行时期，动态的生成代理对象的！
- 目标对象一定要实现接口, 代理对象不用实现接口!
JDK 生成代理对象的Api (Proxy)
static Object
newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
参数loader :
当前目标对象使用的类加载器！
参数interfaces :
当前目标对象实现的接口
参数 h:
接口类型，事件处理器.
当执行目标对象方法的时候，会触发事件； 把当前执行的方法(method对象)，传入事件处理器方法参数中, 这样就可以根据业务逻辑，判断是否执行目标对象方法或扩展功能！
类
public interface UserDao {
public void save();
public void find();
}
public class UserDaoImpl implements UserDao {
public void save(){
System.out.println("正在存储");
}
public void find(){
System.out.println("正在查找");
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyFactory {
private Object target; //目标对象
public ProxyFactory(Object target){
this.target = target;
}
public Object getProxyInstance(){
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler(){
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
if(method.getName().equals("save")){
System.out.println("开启事务");
result = method.invoke(target, args);
System.out.println("提交事务");
}else{
result = method.invoke(target, args);
}
return result;
}
}
);
return proxy;
}
}
public class App {
@Test
public void test(){
//创建目标对象
UserDaoImpl userDaoImpl = new UserDaoImpl();
UserDao proxy = (UserDao) new ProxyFactory(userDaoImpl).getProxyInstance();
/*代理类也会去实现目标对象实现的接口； 所以也属性接口类型*/
proxy.save();
}
}
Cglib代理
也叫”子类代理”
当目标对象没有实现接口，就不能使用jdk提供的代理，可以以子类的方式实现！
在运行时期动态在内存中构建一个子类对象的方法，从而对目标对象扩展，这种就是cglib代理！
Spring也支持cglib代理，核心包中已经包含此功能！
- JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。
- CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
- CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
总结：
- 目标对象可以不实现接口
- 目标类不能为final， 如果为final报错
- 方法如果为final/static, 不会被代理拦截！ 会直接执行目标对象方法！
类：
public class UserDao {
public void save(){
System.out.println("已经save");
}
public void find(){
System.out.println("已经find");
}
}
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.InvocationHandler;
public class ProxyFactory implements InvocationHandler{
private Object target; //目标对象
public ProxyFactory(Object target){
this.target = target;
}
//返回目标对象的子类代理对象
public Object getProxyInstance(){
//字节码生成工具类
Enhancer enhancer = new Enhancer();
//设置父类
enhancer.setSuperclass(target.getClass());//目标对象就是父类
//设置回调函数
enhancer.setCallback((Callback) this);
return enhancer.create();
}
@Override
public Object invoke(Object arg0, Method method, Object[] args) throws Throwable {
Object result = null;
if(method.getName().equals("save")){
System.out.println("开启事务");
result = method.invoke(target, args);
System.out.println("提交事务");
}else{
result = method.invoke(target, args);
}
return result;
}
}
public class App {
@Test
public void test(){
//创建目标对象
UserDao userDao = new UserDao();
UserDao proxy = (UserDao) new ProxyFactory(userDao).getProxyInstance();
/*代理类也会去实现目标对象实现的接口； 所以也属性接口类型*/
proxy.save();
proxy.find();
}
}
