java,代理模式（静态代理，动态代理）

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.

好处:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.

编程思想:不随意修改已经写好的代码或者方法,如果需要修改,可以通过代理的方式来扩展该方法。

静态代理（只能代理唯一的对象）：

静态代理，需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类.

代码如下：

/**
* @Description:静态代理接口
* @author：Dxh
* @date：2017年12月23日
*/
public interface UserManager {

public void addUser(String userId, String userName);

public void delUser(String userId);

public String findUser(String userId);

public void modifyUser(String userId, String userName);

}

/**
* @Description:委托代理类
* @author：Dxh
* @date：2017年12月23日
*/
public class UserManagerImpl implements UserManager{

@Override
public void addUser(String userId, String userName) {
System.out.println("UserManagerImpl.addUser");

}

@Override
public void delUser(String userId) {
System.out.println("UserManagerImpl.delUser");

}

@Override
public String  findUser(String userId) {
System.out.println("UserManagerImpl.findUser");
return "张三";
}

@Override
public void modifyUser(String userId, String userName) {
System.out.println("UserManagerImpl.modifyUser");

}

}

/**
* @Description:代理类
* @author：Dxh
* @date：2017年12月23日
*/
public class UserManagerImplProxy implements UserManager{

//目标对象
private UserManager userManager;

//通过构造方法传入目标对象
public UserManagerImplProxy(UserManager userManager) {
this.userManager = userManager;
}

@Override
public void addUser(String userId, String userName) {

try {
//开始添加用户
System.out.println("start-->addUser()");
userManager.addUser(userId, userName);
//添加用户成功
System.out.println("success-->addUser()");

} catch (Exception e) {
// 添加用户失败
System.out.println("fail-->addUser()");
}

}

@Override
public void delUser(String userId) {
userManager.delUser(userId);
}

@Override
public String findUser(String userId) {
userManager.findUser(userId);
return "张三";
}

@Override
public void modifyUser(String userId, String userName) {
userManager.modifyUser(userId, userName);
}

}

/**

* @Description:客户端调用代理类

* @author：Dxh

* @date：2017年12月23日

*/

public class Client {

//静态代理
public static void main(String[] args) {
//UserManager userManager = new UserManagerImpl();
UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
userManager.addUser("001", "张三");
}

}

输出结果为：

start–>addUser()

UserManagerImpl.addUser

success–>addUser()

动态代理（可以代理不同的对象）：

代理类都需要实现InvocationHandler类，实现Invoke方法。

public class LogHandler implements InvocationHandler{

//目标对象
private Object targerObject;

//绑定关系，也就是关联到哪个接口(与具体的实现类绑定)的哪些方法被调用时，执行invoke方法
public Object newProxyInstance(Object targetObject){
this.targerObject = targetObject;
//该方法用于为指定类加载器，一组接口及调用处理器生成动态代理类实例
//第一个参数指定产生代理对象的类加载器， 需要将其指定为和目标对象同一个类加载器
//第二个参数需要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口
//第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的Invoke方法
//method存在.getName()方法，可获取被代理对象中的方法名
//根据传入的目标返回一个代理对象
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(), this);
}

@Override
//关联的这个实现类的方法，被调用时将被执行
//InvocationHandler接口的方法，proxy标识代理，method表示原对象被调用的方法，args标识方法的参数
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("start--->");
for(int i = 0; i<args.length; i++){
System.out.println(args[i]);
}

Object resultObject = null;

try {
//原对象方法调用前处理日志信息
System.out.println("start--->");
//调用目标方法
resultObject = method.invoke(targerObject, args);
//原对象方法调用后处理日志信息
System.out.println("success--->");
} catch (Exception e) {
e.printStackTrace();
System.out.println("error--->");
throw e;
}

return resultObject;
}
}

public class Client {
//动态代理
public static void main(String[] args) {
LogHandler logHandler = new LogHandler();
UserManager userManager = (UserManager) logHandler.newProxyInstance(new UserManagerImpl());
userManager.addUser("001", "张三");
}

}

输出为：

张三

start—>

UserManagerImpl.addUser

success—>