动态代理(含基础代码)

动态代理(含基础代码)

最后修改时间:a month ago

刚开始是为了解决实体类过多而想尝试创建动态实体类···

一般动态代理是加载service层与dao层之间,用来有效控制对委托类对象的直接访问,也可以很好地隐藏和保护委托类对象(我不懂啥保护隐藏,我就是想让它自动创建实体类,或者通过父类去引导至实体类层),动态代理的底层实现逻辑大概就是···读写本地文本文件后将文件进行编译再运行实现的···

编译java类方法

    public void javac(String writerPath){  
        //java编译器  
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();  
        //文件管理器,参数1:diagnosticListener  监听器,监听编译过程中出现的错误  
        StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);  
        //java文件转换到java对象,可以是多个文件  
        Iterable<? extends JavaFileObject> it = manager.getJavaFileObjects(writerPath);  
        //编译任务,可以编译多个文件  
        CompilationTask t = compiler.getTask(null, manager, null, null, null, it);  
        //执行任务  
        t.call();  
        try {  
            manager.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行java类方法

     /** 
     * 利用反射,实例化对象,此方法可指定class路径,放在classpath下可能会和jdk编译的文件冲突 
     * @param packPath 
     */  
    public void java(String packPath){  
        URL[] urls = null;  
        try {  
            //类路径,url的本地文件格式需要加file:/  
            urls = new URL[] {new URL("file:/"+System.getProperty("user.dir")+"/src/")};  
        } catch (MalformedURLException e) {  
            e.printStackTrace();  
        }  
        //类加载器  
        URLClassLoader url = new URLClassLoader(urls);  
        Class clazz = null;  
        try {  
            //加载到内存  
            clazz = url.loadClass(packPath);  
            //实例化对象  
            clazz.newInstance();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

动态代理的底层就是编译运行动态java文件(感觉动态实体类指日可待了啊)

动态代理目前了解到的几种方式: 1、JDK动态代理 2、CGLIB动态代理 最近接触到的框架那就是springboot,简单粗暴,内置org.springframework.cglib包,直接能用第二种···所以···走起(以下代码为转载···亲测可用)

第一步:创建DynamicBean 实体类

public class DynamicBean {

    private Object target;
    private BeanMap beanMap;

    public DynamicBean(Class superclass, Map<String, Class> propertyMap) {
        this.target = generateBean(superclass, propertyMap);
        this.beanMap = BeanMap.create(this.target);
    }

    public void setValue(String property, Object value) {
        beanMap.put(property, value);
    }

    public Object getValue(String property) {
        return beanMap.get(property);
    }

    public Object getTarget() {
        return this.target;
    }
    /**
     * 根据属性生成对象
     *
     */
    private Object generateBean(Class superclass, Map<String, Class> propertyMap) {
        BeanGenerator generator = new BeanGenerator();
        if (null != superclass) {
            //cglib需要指定父类
            generator.setSuperclass(superclass);
        }
        BeanGenerator.addProperties(generator, propertyMap);
        return generator.create();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

第二步:创建映射类,用来生成动态bean

public class ReflectUtil {
	private static Logger logger = LoggerFactory.getLogger(ReflectUtil.class);
	
	public static Object getObject(Object dest, Map<String, Object> addProperties) {
	    PropertyUtilsBean propertyUtilsBean = new PropertyUtilsBean();
	    PropertyDescriptor[] descriptors = propertyUtilsBean.getPropertyDescriptors(dest);
	    Map<String, Class> propertyMap = Maps.newHashMap();
	    for (PropertyDescriptor d : descriptors) {
	        if (!"class".equalsIgnoreCase(d.getName())) {
	            propertyMap.put(d.getName(), d.getPropertyType());
	        }
	    }
	    addProperties.forEach((k, v) -> {
	    	String sclass = v.getClass().toString();
	    	if(sclass.equals("class java.util.Date")) {//对日期进行处理
	    		propertyMap.put(k, Long.class);
	    	}else {
	    		propertyMap.put(k, v.getClass());
	    	}
	    	
	    });
	    DynamicBean dynamicBean = new DynamicBean(dest.getClass(), propertyMap);
	    propertyMap.forEach((k, v) -> {
	        try {
	            if (!addProperties.containsKey(k)) {
	                dynamicBean.setValue(k, propertyUtilsBean.getNestedProperty(dest, k));
	            }
	        } catch (Exception e) {
	            logger.error("动态添加字段出错", e);
	        }
	    });
	    addProperties.forEach((k, v) -> {
	        try {
	        	String sclass = v.getClass().toString();
		    	if(sclass.equals("class java.util.Date")) {//动态添加的字段为date类型需要进行处理
		    		Date date = (Date) v;
		    		dynamicBean.setValue(k, date.getTime());
		    	}else {
		    		dynamicBean.setValue(k, v);
		    	}
	        } catch (Exception e) {
	        	logger.error("动态添加字段值出错", e);
	        }
	    });
	    Object obj = dynamicBean.getTarget();
	    return obj;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

第三步:增添属性值:

User user = new User();
user.setName("Daisy");
System.out.println("User:"+JSON.toJSONString(user));
Map<String,Object> propertiesMap = new HashMap<String,Object>();
propertiesMap.put("age", 18);
Object obj = ReflectUtil.getTarget(user, propertiesMap);
System.out.println("动态为User添加age之后,User:"+JSON.toJSONString(obj));
1
2
3
4
5
6
7

这样动态实体类就可以使用了 在这里插入图片描述

然而···然而···有啥用呢???不同的service都需要请求不同的dao层,然而不同的dao层要通过这一个方法来改变这一个实体类···冲突是必然的,除非依然根据service来创建不同的实体类层···无非就是不用一遍遍删改里面的属性了···用list<object[]>不也很香??? (/"≡ _ ≡)/~┴┴ (/"≡ _ ≡)/~┴┴ (/"≡ _ ≡)/~┴┴

- 全文完 -

留下一条留言?
默认颜色

主题颜色

标准颜色

更多颜色...