南贺神社

你写程序有写诗一样的感觉吗?

0%

Posted on Edited on In Views:

这里写图片描述
思想：定 义一系列的算法,把它们一个个封装起来, 并 且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
场景：该 模式实际上也可以理解为一种Bridge模式的变种。只是它突出的是，一般当我们把一个类或者一组 类的一些代码独立成一个Strategy类的时候，我们可能会为同样接口的这些算法定义多个接口一 致，但是实现方法不同的版本，并在需要的时候灵活的替换这些算法。

Read more »

Posted on Edited on In Views:

思想：提 供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
场景：访 问一个聚合对象的内容而无需暴露它的内部表示。支持对聚合对象的多种遍历。为遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
实现：其 实就是定义一个逻辑上类似一个指针的迭代类。专门用于这种迭代工作。如果对C++ STL火锅功夫 学习的朋友一定不会陌生啦。实际使用过一下就明白了。除了功能之外，他给我最大的感受就是他让我熟悉的for语句，变长了好多。^-^

Read more »

Posted on Edited on In Views:

这里写图片描述
1、静态代理：

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
<!-- more -->
interface ProxyBase{
	public void f();
	public void g();
	public void h();
}
//代理程序
class Proxy implement ProxyBase{
	private ProxyBase implementation;
	public Proxy(){
		//目标程序
		implementation = new ProxyImplementation();
	}
	public void f(){
		implementation.f();
	}
	public void g(){
		implementation.g();
	}
	public void h(){
		implementation.h();
	}
}
//目标程序
class ProxyImplementation implements ProxyBase{
	public void f(){
		System.out.println(“ProxyImplementation.f()”);
	}
	public void g(){
		System.out.println(“ProxyImplementation.g()”);
	}
	public void h(){
		System.out.println(“ProxyImplementation.h()”);
	}
}
//客户端程序调用代理
public class ProxyDemo{
	public static void main(String[] args){
		//客户端调用代理程序
		Proxy p = new Proxy();
		p.f();
		p.g();
		p.h();
	}
}

2、动态代理
动态代理分为JDK的接口动态代理和CGLIB的基于类的动态代理，
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
jdk动态代理：
jdk动态代理的实现原理参考

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
//代理接口
interface Foo{
	public void f(String s);
	public void g(int i);
	public void h(int i, String s);
}
//接口实现类，即被代理类
class FooImpl implements Foo{
	public void f(String s){
		System.out.println(“FooImpl.f(), s=” + s);
	}
	public void g(int i) {
		System.out.println(“FooImpl.g(), i=” + i);
	}
	public void h(int i, String s) {
		System.out.println(“FooImpl.h(), i=” + i + “, s=” + s);
	}
}
//动态代理处理类
class ProxyHandler implements InvocationHandler{
	//代理实现类
	private Object delegate;            
     	public ProxyHandler (Object obj) {    
         	delegate = obj;    
     	}    
	public Object invoke(Object proxy, Method method, Object[] args){
  		System.out.println(“Before mothod:” + method);
  		method.invoke(this.delegate, args);
  		System.out.println(“After mothod:” + method);
  		return null;
	}
}
public class DynamicProxyDemo{
	public static void main(String[] args){
		Foo foo = new FooImpl();
		ProxyHandler handler = new ProxyHandler(foo);
		//产生动态代理
	Foo proxy = (Foo)Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class[]{Foo.class}, handler);
		proxy.f(“f”);
		proxy.g(1);
		proxy.h(“h”, 2);
	}
}

CGLIB动态代理
在使用CGLIB时需引入cglib-nodep-2.1_3.jar包
被代理对象

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.ljq.test;

/**
 * 定义一个HelloWorld类
 *
 * @author jiqinlin
 *
 */
public class HelloWorld {
    public void sayHelloWorld() {
        System.out.println("HelloWorld!");
    }
}

代理类

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
49
50
51
52
53
54
55
56
57
58
59
60
package com.ljq.test;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
 * 通过Cglib实现在方法调用前后向控制台输出两句字符串
 *
 * @author jiqinlin
 *
 */
public class CglibProxy implements MethodInterceptor {
    //要代理的原始对象
    private Object obj;

    public Object createProxy(Object target) {
        this.obj = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.obj.getClass());// 设置代理目标
        enhancer.setCallback(this);// 设置回调
        enhancer.setClassLoader(target.getClass().getClassLoader());
        return enhancer.create();
    }


    /**
     * 在代理实例上处理方法调用并返回结果
     *
     * @param proxy
     *            代理类
     * @param method
     *            被代理的方法
     * @param params
     *            该方法的参数数组
     * @param methodProxy
     */
    public Object intercept(Object proxy, Method method, Object[] params,
            MethodProxy methodProxy) throws Throwable {
        Object result = null;
        // 调用之前
        doBefore();
        // 调用原始对象的方法
        result = methodProxy.invokeSuper(proxy, params);
        // 调用之后
        doAfter();
        return result;
    }

    private void doBefore() {
        System.out.println("before method invoke");
    }

    private void doAfter() {
        System.out.println("after method invoke");
    }

}

测试类

1
2
3
4
5
6
7
8
9
10
11
package com.ljq.test;

public class HelloWorldTest {

    public static void main(String[] args) {
        HelloWorld helloWorld=new HelloWorld();
        CglibProxy cglibProxy=new CglibProxy();
        HelloWorld hw=(HelloWorld)cglibProxy.createProxy(helloWorld);
        hw.sayHelloWorld();
    }
}

Posted on Edited on In Views:

12.1设计原理
对ibatis的使用相对来说比较简单，在spring的封装中，有几个基本过程，首先需要创建sqlmapclient，这个sqlmapclient类似于在hibernate中的session，对于它的创建，在spring中设计sqlmapclientfactorybean，通过这个factorybean；哎读取sqlmapclient的配置和具体创建。在配置和创建好sqlmapclient之后，在spring中同样为sqlmapclient的使用封装了sqlmapclienttemplate，他同样作为一个模板，封装了通过sqlmapclient完成的主要操作。

Read more »

Posted on Edited on In Views:

11.1事物的创建
TransactionInterceptor的invoke的回调过程中会使用createTransactionIfNecessary，这个方法在其基类TransactionAspectSupport中实现，期间会使用AbstractPlatformTransactionManager调用getTransaction(txAttr)，这个过程要对不同情况进行处理，得到TransactionStatus，然后塞进TransactionInfo中，最后将TransactionInfo与当前线程绑定，TransactionInfo穿插在整个事物处理过程中。
createTransactionIfNecessary的调用时序图：

Read more »