刚开始是为了解决实体类过多而想尝试创建动态实体类···
一般动态代理是加载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
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
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
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
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
2
3
4
5
6
7
这样动态实体类就可以使用了
然而···然而···有啥用呢？？？不同的service都需要请求不同的dao层，然而不同的dao层要通过这一个方法来改变这一个实体类···冲突是必然的，除非依然根据service来创建不同的实体类层···无非就是不用一遍遍删改里面的属性了···用list<object[]>不也很香？？？ (/"≡ _ ≡)/~┴┴ (/"≡ _ ≡)/~┴┴ (/"≡ _ ≡)/~┴┴