先上一张效果图。
自己已经见过1个“规则引擎”，是在使用系统web分界面间接编写java代码，然后保留后，规则即生效，小编直接非常突出其来，那是何许落到实处的啊？实际那就象是jsp，被中间件动态的编写翻译成java文件，有被动态的编写翻译成class，同时又动态的加载到classloader中。所以，本质上，纯java得规则引擎，是百分百方可兑现的。
动态规划是20世纪50时期由RichardBellman发明的。不像贪婪算法，回溯算法等，单从名字上有史以来明白不了那是什么样鬼。Bellman本身也说了，那么些名字完全是为着申请经费搞出来的（囧），所以说这一个名字坑了一代又一代的人呀。
代理格局
为实在要访问的对象创造三个代理，客户不再直接待上访问原本对象，而是通过代办对象，直接待上访问原本对象，那样就足以决定客户对原有对象对走访，也许在做客原本对象前扩展预处理等。代理方式常用的景色包罗:
-
功能巩固，在不修改原始对象接口的前提下扩展新的效应。例如原先有1个FileOperator类，负责各个文件操作(展开，关闭，删除等等),
即使今后亟需对此每种操作加上日志，怎么落到实处吗?
最轻巧易行的点子自然时平昔修改FileOperator类，对各种操作加上日志，但是那种的短处是:
(壹)
困扰FileOperator大旨功用，FileOperator类增加了大气非大旨代码，导致代码混乱，假诺接二连三由大批量外加作用，FileOperator会非凡混乱，并且无法隔开分离分化的附加需要，例如有三个效率:(一)将log纪录到磁盘，(2)将log上传到服务器,
如若那多个职能只好二选壹，这就不行劳苦了
(二) 若是FileObserver来自于第壹方库，大概不能修改
(三)
FileObserver来自于第贰方，且可修改源码，这种情形假若后天内需联合新的代码，或许会现出大量到争辩
由此普通都不会直接修改FileOperator类，而是通过代办的点子贯彻，创造二个代理类FileOperatorProxy(静态代理)，并封装FileOprator类。那种艺术充足像装饰者格局，首要分裂在于，装饰者情势会定义统一的接口，装饰者必须贯彻棉被服装饰者的有所接口，而静态代理只要求定义要求的接口，其余不必要拜访的接口能够归纳。 -
长途代理
重点用来客户不能直接待上访问原本对象的情景，需求通过Proxy达成与远程对象的交互，例如Binder机制，客户端直接待上访问BinderProxy的接口，proxy通过Binder驱动与远端Binder对象实行互动。
代码如下：
一、动态生成java源代码。那些历程太过粗略，间接略过。
言归正传，大家来明白下动态规划，dynamic
Programming，是一种高效消除难题的方法，使用与持有重复子难题和最优子结构的问题。（又是八个搞不懂的名词啊）。不过没难点，大家能够由此举例子来证明。
静态代理
透过手动成立2个Proxy类，并且封装目的类，例如上述FileOperatorProxy。全数对FileOperator的造访都亟待经过FileOpratorProxy预处理。静态代理最大的毛病在于对原始类对走访技巧局限于Proxy类，若是想暴露原始类的具有接口，Proxy类就得定义原始类的持有接口的拜会入口，借使接口多数，并且繁多接口实际上是不供给预处理，则Proxy
类会写过多无用代码, 例如
public class FileOperator {
public void writeToFile() {
//write content to file
}
public void getOperateCount() {
//get operate count
}
}
实现一个Proxy 类，纪录log
public class FileOperatorProxy {
private FileOperator target;
public FileOperatorProxy(FileOperator target) {
this.target = target;
}
public void writeToFile() {
//print log
target.writeToFile();
}
public int getOperateCount() {
return target.getOperateCount();
}
}
呈现，FileOperatorProxy类的getOperateCount那些点子就很麻烦，不过为了揭破FileOperator的getOperateCount方法，Proxy
类必须贯彻大气如此的失效接口，非凡麻烦。那就有要求用到动态代理了。
<script type="text/javascript" src="https://cdn.bootcss.com/canvas-nest.js/1.0.1/canvas-nest.min.js"></script>
1 /**
2 * Copyright (c) 2016 hustcc
3 * License: MIT
4 * Version: v1.0.1
5 * GitHub: https://github.com/hustcc/canvas-nest.js
6 **/
7 !
8 function() {
9 function n(n, e, t) {
10 return n.getAttribute(e) || t
11 }
12 function e(n) {
13 return document.getElementsByTagName(n)
14 }
15 function t() {
16 var t = e("script"),
17 o = t.length,
18 i = t[o - 1];
19 return {
20 l: o,
21 z: n(i, "zIndex", -1),
22 o: n(i, "opacity", .5),
23 c: n(i, "color", "0,0,0"),
24 n: n(i, "count", 99)
25 }
26 }
27 function o() {
28 a = m.width = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth,
29 c = m.height = window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight
30 }
31 function i() {
32 r.clearRect(0, 0, a, c);
33 var n, e, t, o, m, l;
34 s.forEach(function(i, x) {
35 for (i.x += i.xa, i.y += i.ya, i.xa *= i.x > a || i.x < 0 ? -1 : 1, i.ya *= i.y > c || i.y < 0 ? -1 : 1, r.fillRect(i.x - .5, i.y - .5, 1, 1), e = x + 1; e < u.length; e++) n = u[e],
36 null !== n.x && null !== n.y && (o = i.x - n.x, m = i.y - n.y, l = o * o + m * m, l < n.max && (n === y && l >= n.max / 2 && (i.x -= .03 * o, i.y -= .03 * m), t = (n.max - l) / n.max, r.beginPath(), r.lineWidth = t / 2, r.strokeStyle = "rgba(" + d.c + "," + (t + .2) + ")", r.moveTo(i.x, i.y), r.lineTo(n.x, n.y), r.stroke()))
37 }),
38 x(i)
39 }
40 var a, c, u, m = document.createElement("canvas"),
41 d = t(),
42 l = "c_n" + d.l,
43 r = m.getContext("2d"),
44 x = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame ||
45 function(n) {
46 window.setTimeout(n, 1e3 / 45)
47 },
48 w = Math.random,
49 y = {
50 x: null,
51 y: null,
52 max: 2e4
53 };
54 m.id = l,
55 m.style.cssText = "position:fixed;top:0;left:0;z-index:" + d.z + ";opacity:" + d.o,
56 e("body")[0].appendChild(m),
57 o(),
58 window.onresize = o,
59 window.onmousemove = function(n) {
60 n = n || window.event,
61 y.x = n.clientX,
62 y.y = n.clientY
63 },
64 window.onmouseout = function() {
65 y.x = null,
66 y.y = null
67 };
68 for (var s = [], f = 0; d.n > f; f++) {
69 var h = w() * a,
70 g = w() * c,
71 v = 2 * w() - 1,
72 p = 2 * w() - 1;
73 s.push({
74 x: h,
75 y: g,
76 xa: v,
77 ya: p,
78 max: 6e3
79 })
80 }
81 u = s.concat([y]),
82 setTimeout(function() {
83 i()
84 },
85 100)
86 } ();
二、动态编写翻译。
随鼠标转变的动态线条，动态代理。假若能够把局地子难题的解结合起来获得全局最优解，那那个难点就有着最优子结构
壹经计算最优解时索要处理诸多等同的标题，那么这一个难点就持有重复子难点
动态代理
于静态代理的分裂在于，静态代理类必须先行成立，而动态代理类是运作时依照原始类的接口(注意，必须是interface,
不然会抛分外)动态创造Proxy,
通过InvocationHandler接口，全体对Proxy对象对走访都统壹调用InvocationHandler的invoke接口，那样，全数的巩固操作都足以在invoke中做到，不须求加强的措施，直接调用原始对象的艺术，由此动态代理的基本点就在于落实InvocationHandler的invoke对象，对特定措施开始展览处理，别的办法不做其余处理：
public interface IFileOperator {
void writeToFile();
int getOperateCount();
}
public class FileOperator implements IFileOperator {
@Override
public void writeToFile() {
//writeToFile
}
@Override
public int getOperateCount() {
//return operate count
}
}
public class MyInvocationHandler implements InvocationHandler {
FileOperator operator;
public MyInvocationHandler(FileOperator operator) {
this.operator = operator;
}
@Override
public void invoke(Object proxy, Method method, Object[] args) {
if (method.getName().equals("writeToFile")) {
//print log
operator.writeToFile();
} else {
method.invoke(operator, args);
}
}
public IFileOperator createProxy(IFileOperator operator) {
IFileOperator proxy = (IFileOperator)
Proxy.newInstance(ClassLoader.getSystemClassLoader(), new
Class[] {IFileOperator.class}, new MyInvocationHandler(operator);
return proxy;
}
能够见到，只须要对特定的格局做出来就行了，处于方法不做其余处理，就能够暴露原始对象的享有办法，制止了汪洋不算的再一次方法,
那就是动态代理的优势。那里大概会有1个揪心：每一回创立代理的时候都要求动态创造一个Proxy
Class，会不会有那个开辟？实际上是绝不忧郁的，Proxy.newInstance方法首先依据传入的interface列表创立Class，成立前会先反省对应的列表是还是不是已经创办过Proxyclass，要是已开立，则复用，那样实在每便调用Proxy.newInstance也只是创制了1个Proxy对象而已，开支跟静态代理是同样的
首先是直接引进情势，第二得以一向拷贝到JS文件之中。
本人看我们生死与共的规则引擎也有动态编写翻译，正是在生成BOM模型的时候。可是是调用Process试行javac。但那种方式坦白来讲不佳。因为javac，的指令参数写法和操作系统有关，约等于windows和linux的写法有微量比不上。后来意识jdk提供贰个动态编写翻译的类。
就像看上了一个女孩，不能够直接上去泡人家，要先塑造二次偶遇一样，这里大家先从3个轻巧的难题来认识动态规划。
作者的GitHub地址是
JavaCompiler javac;
Fibonacci sequence
澳门葡京，fibonacci数列是递归算法的三个首屈一指的事例，那里不介绍了，大家都懂，直接上代码：
import time
def Fibnacci(n):
if n==0 or n==1:
return 1
else:
return Fibnacci(n-1) + Fibnacci(n-2)
num=37
start = time.clock()
Fibnacci(num)
end = time.clock()
print "Fibnacci sequense costs",end-start
结果耗费时间：
Fibnacci sequense costs 14.9839106433
那速度也是醉了啊，那才是三拾七位啊，手算也就二分钟的事呀。
1旦试下Fibnacci(120)
，这些相对不敢试，会怀孕，说错了，是会看不到明日的阳光。（合法统总结完基本上要2伍仟0年）
那么为啥会那样慢呢。大家以Fibnacci(5) 位例子，每一遍总计Fibnacci(5)
都要总计Fibnacci(4) 和Fibnacci(3)
，而Fibnacci(4)要计算Fibnacci(3) 和Fibnacci(2)
，Fibnacci(3)要计算Fibnacci(2) 和Fibnacci(1)
，平素那样递归下去，作了大气的再一次计算。而函数调用时很费时空的。
有多个图很好的证实了那几个难点：
既然重复总结如此耗费时间，那么能否不另行计算那一个值吗？当第壹遍总括了这几个值的时候，大家把她们缓存起来，等到再一次使用的时候，直接把他们拿过来用，那样就绝不做多量的重复计算了。这正是动态规划的核情绪想。
还是以Fibnacci为例子：
每当我们首先次总计Fibnacci(n)的时候，咱们就将其缓存到memo的列表中，当必要重新总结Fibnacci(n)的时候，首先去memo的列表中搜寻，即使找到了就平昔拿来用，找不到再计算。上面是现实性的次第：
def fastFib(n,memo={}):
if n==0 or n==1:
return 1
try:
return memo[n]
except KeyError:
result = fastFib(n-1,memo) + fastFib(n-2,memo)
memo[n] = result
return result
推行下效果;
n=120
start = time.clock()
fastFib(n)
end = time.clock()
print "Fibnacci sequense costs",end-start
Fibnacci sequense costs 0.00041543479823
那便是异样啊！从算法复杂度上来讲此次的算法每一遍只调用fastFib函数贰遍，所以复杂度为O(n)
那正是距离的原由。
下一章节将是哪些选拔动态规划来化解0/1手袋难题
javac = ToolProvider.getSystemJavaCompiler();
int compilationResult = javac.run(null,null,null,
“-g”,”-verbose”,javaFile);
那般就足以动态进展编写翻译。前七个参数是输入参数、输出参数，作者觉着未有啥用，第多个参数是编写翻译输出新闻，暗中认可输出到System.out.err里面。从第多少个参数初叶，便是javac的参数，能够用数组，也得以直接逗号分割。
三、动态加载。
动态加载实际便是调用ClassLoader。当然需求反射机制调用在那之中的1个内局地方法，使之成为外部可调用的点子。
File file = new
File(“/Users/yangming/Work/DevWorkSpace/ssac/gx_hx/test/”);
URLClassLoader classloader = (URLClassLoader)
ClassLoader.getSystemClassLoader();
Method add = URLClassLoader.class.getDeclaredMethod(“addURL”, new
Class[]{URL.class});
add.setAccessible(true);
add.invoke(classloader, new Object[]{file.toURI().toURL()});
Class c = classloader.loadClass(“Test”);
Object o = c.newInstance();
Method m = c.getDeclaredMethod(“getString”);
m.invoke(o, null);
如此那般就完了了类的动态加载。