jdk动态代理

自学spring的主观理解总结，有错误，请指正
代理模式中存在三种角色：抽象角色、真实角色、代理角色

创建model

package com.shuting.model;

public class User {

	package com.shuting.model;

public class User {

	private String username;
	private Integer age;
	private String gender;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "User [username=" + username + ", age=" + age + ", gender=" + gender + "]";
	}
}

创建抽象角色

package com.shuting.service;

public interface UserService {

	public void save();
	
	public void update();
}

创建真实角色

真实角色实现抽象角色

package com.shuting.service.impl;
/*
 * 业务实现类中的所有方法的操作交给代对象
 */
import com.shuting.model.User;
import com.shuting.service.UserService;

public class UserServlceImpl implements UserService {

	private User User = null;
	
	public User getUser() {
		return User;
	}

	public void setUser(User user) {
		User = user;
	}

	@Override
	public User save() {
		System.out.println("保存对象");
		return User;
	}

	@Override
	public User update() {
		System.out.println("更改对象");
		return User;
	}
}

创建代理角色

代理角色需要实现InvocationHandler接口，再实现借口而下的invoke方法

package com.shuting.proxy;

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

import com.shuting.service.impl.UserServlceImpl;

public class JDKProxy implements InvocationHandler {
/*
 * 代理对象
 */
	private Object obj;
/*
 * newProxyInstance静态方法根据参数loader、Interfaces调用方法getProxyClass(Loader,Interfaces),创建了一个代理类$Proxy0,该类中能够实现被代理类中的业务方法的代理
 * 	根据静态方法实例化$Proxy0调用父类构造方法，利用JDKProxy为InvocationHandle对象赋值
 * 
 * 第一个参数：真实对象的类加载器，可以认为是提供类的业务方法给代理对象
 * 第二个参数：$Proxy0实现的接口
 * 第三个参数：回调对象，当$Proxy0代理对象的代理方法invoke被调用时，会委派参数InvocationHandle h去调用当前类中的invoke方法
 */
	public Object createProxy(Object obj1) {
		this.obj = obj1;
		return Proxy.newProxyInstance(this.obj.getClass().getClassLoader(), this.obj.getClass().getInterfaces(), this);
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println(method.getName());
		Method method2 = obj.getClass().getMethod("getUser", null);
		Object object = method2.invoke(obj, null);
		Object object2 = null;
		if(object != null) {
			object2 = method.invoke(obj, args);
		}else {
			System.out.println("没有登录");
		}
		
		return object2;
	}
}

客户端

package com.shuting.test;

import java.lang.reflect.Field;
import java.lang.reflect.Proxy;

import com.shuting.model.User;
import com.shuting.proxy.JDKProxy;
import com.shuting.service.UserService;
import com.shuting.service.impl.UserServlceImpl;
import com.sun.org.apache.xml.internal.utils.SuballocatedByteVector;

public class Test {

	public static void main(String[] args) {
	
		UserServlceImpl usi = new UserServlceImpl();
		usi.setUser(null);
		UserService createProxy = (UserService)new JDKProxy().createProxy(usi);
		User save = createProxy.update();
	}
}