jdk代理
    解释:程序在运行过程中，根据被代理的接口来动态生成代理类的class文件，并且加载运行。
    JDK提供了java.lang.reflect.Proxy类来实现动态代理的，可通过它的newProxyInstance来获得代理实现类。
1:自定义接口
package javabase.allinterface;

public interface SaySimple {
    
    void sayHelloForSomeone(String name);
    
}
2:接口实现类
package javabase.allimpl;

import javabase.allinterface.SaySimple;

public class SaySimpleImpl01 implements SaySimple{

    @Override
    public void sayHelloForSomeone(String name) {
        System.out.println("Hello!"+name);
    }

}
3：自定义实现InvocationHandler接口的类

package javabase;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ImplInvocationHandler implements InvocationHandler {
    
    private Object targetObj;
    
    public ImplInvocationHandler(Object obj) {
        this.targetObj = obj;
    }
    
    /**
     * @return
     * GY
     * 2017年11月6日
     */
    public Object getProxy(){
        return java.lang.reflect.Proxy.newProxyInstance(targetObj.getClass().getClassLoader(), 
                targetObj.getClass().getInterfaces(), 
                new ImplInvocationHandler(targetObj));
    }

    /*
     * 
     * 
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invocation");
        Object retVal = method.invoke(targetObj, args);
        System.out.println("After invocation");
        return retVal; 
    }

}

4：测试，用代理对象执行被代理接口实现类的方法
package javabase;

import java.lang.reflect.Proxy;

import javabase.allimpl.SaySimpleImpl01;
import javabase.allinterface.SaySimple;

public class TestOfInvocationHandler {

    public static void main(String[] args) {
        SaySimple s = new SaySimpleImpl01();
        ImplInvocationHandler handle = new ImplInvocationHandler(s);
        
        SaySimple proxy = (SaySimple)Proxy.newProxyInstance(//TestOfInvocationHandler.class.getClassLoader(), 
                                                            handle.getClass().getClassLoader(),
                                                            //new Class[]{SaySimple.class},
                                                            s.getClass().getInterfaces(),
                                                            handle);
        proxy.sayHelloForSomeone("GY");
        
        SaySimple proxy2 = (SaySimple)handle.getProxy();
        proxy2.sayHelloForSomeone("WX");
    }

}

                                                    
package com.java.proxy.jdk;

public interface Student {
	public void addStudent ();
}


package com.java.proxy.jdk;

public class StudentImpl implements StudentDao{

	public void addStudent () {
		System.out.println("正在插入学生信息...");
	}
	
}



package com.java.proxy.jdk;



public class JDKProxy {
	public static void main(String[] args) {
		//1.创建一个对象
		StudentDao dao = new StudentImpl();
		dao.add();
    //此处输出：正在插入学生信息...
	}
}

但是我们这里血药用到jdk的动态代理：

代码如下：
package com.java.proxy.jdk;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// JDK是对对象做代理
public class JDKProxy implements InvocationHandler{
	
	private StudentDao  studentDao;  //定义一个全局变量方便后面用到

	//定义一个方法用于创建JDK代理对象
	//JDK代理是对对象做代理
	public StudentDaocreateProxyObject(StudentDao  studentDao){
		//被代理对象作为参数传入进来
		this.studentDao= studentDao; 
		//获取类加载器：对谁做代理，使用谁的类加载器
		ClassLoader loader = studentDao.getClass().getClassLoader();
		//获取被代理对象的所有实现接口
		Class<?>[] interfaces = studentDao.getClass().getInterfaces();
		//创建Handler对象
		InvocationHandler h = this;
		Object proxyObject = Proxy.newProxyInstance(loader, interfaces, h); //创建代理对象
		return (StudentDao) proxyObject;
	}

	public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
    //这里面可以写一些你需要增强的代码
		System.out.println("正在连接数据库");
		//对原始操作进行调用（反射）
		method.invoke(studentDao, args);
		System.out.println("开始关闭数据库");
		return null;
	}
	
	public static void main(String[] args) {
		//1.创建一个对象
		UserDao dao = new UserImpl();
		//2.为原始对象创建代理对象
		UserDao daoProxy = new JDKProxy().createProxyObject(dao);  //其中这里面穿的是个对象
		//3.使用代理对象运行操作
		daoProxy.add();
		
/**
*  运行结果 ：正在连接数据库
            正在插入学生信息...
            开始关闭数据库
*
*
/
	}
}
 
希望对你们有帮助，自己也在学习这个，分享下。
                                                    
转载于:https://my.oschina.net/791076963/blog/904144

Java JDK代理与CGLIB代理区别

1、JDK代理与CGLIB代理程序结构

目录

 

1、使用 JDK 代理

2、静态代理与JDK代理对比

1、使用 JDK 代理

使用 JDK 代理完成上一章 静态代理的事务管理的功能。

沿用上一章的几个类：

实体类：User
	
接口：UserService
	
接口实现类： UserServiceImpl
编写JDK 工厂代理类：

package com.lcy.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 基于 JDK 的动态代理工厂
 */
public class ProxyFactory implements InvocationHandler {
    // 1 持有一个目标对象（被代理对象）
    private Object target;
    
    public ProxyFactory(){}
    // 2 注入目标对象
    public ProxyFactory(Object target){
        this.target = target;
    }
    
    // 3 生成代理对象，使用的是反射技术
    public <T> T getProxy() {
        return (T)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    // 4 代理对象执行的方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("使用JDK动态代理----开启事务");
        // 5 调用 目标对象的执行方法
        Object result = method.invoke(target, args);
        System.out.println("使用JDK动态代理----提交事务");
        return result;
    }
}


测试方法：

package com.lcy.test;

import com.lcy.model.User;
import com.lcy.proxy.ProxyFactory;
import com.lcy.service.UserService;
import com.lcy.service.impl.UserServiceImpl;

public class ProxyFactoryTest {

    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        ProxyFactory proxy = new ProxyFactory(userService);
        UserService userServiceProxy = (UserService)proxy.getProxy();
        userServiceProxy.save(new User(3, "张无忌"));
    }

}


程序运行结果：



2、静态代理与JDK代理对比

静态代理：

1、必须实现目标对象接口。如果有多个对象需要代理（相同功能），那就需要给每个对象都定义多个代理的类。比如说 UserService -> UserServiceImplProxy ，DeptService -> DeptServiceImplProxy

UserServiceImplProxy 、DeptServiceImplProxy 这些代理类做的事情都一样，都是开启事务和提交事务。这样会导致系统中会有很多功能一样的代理类

2、一旦目标对象接口发生改变，静态代理的代理类也要跟着修改。比如说 UserService 接口中新增了remove 方法，在 UserServiceImplProxy 代理类中也要现在 remove 方法

JDK 代理：

1、不需要实现目标接口。可以为任意类进行代理。比如说：为 UserService 接口代理，只需要在创建代理类的时候，注入 UserService 接口的实现。然后利用 java反射技术动态生成代理类对象。

2、一旦目标对象接口发生改变，动态代理的代理类无需修改。比如说： UserService 接口新增了 remove 方法，ProxyFactory 代理工厂无需修改。