2018.3.6 SSM 前言完结

  前言：在学习SSM之前，感觉自己还是跟着视频走吧，毕竟自己不是大神，所以，在学习SSM之前 我就学习一些的比较重要的内容，三大代理模式，适配器模式，模板方法。自我感觉这些还是非常重要的，在网上也了解他的重要性。

   三大代理模式：

 <1>静态代理模式:

       通过另一个类来增强目标类的模式，但是目标类必须实现相同的接口或者是继承相同父类.

代码实例

1)定义一个接口点击打开链接

package com.gavin.service;

public interface ISomeService {
	String doFirst();
	void doSecond();
}

2)目标类必须实现接口

package com.gavin.service;

public class ISomeServiceImpl implements ISomeService{

	@Override
	public String doFirst() {
		return "abcde";
	}

	@Override
	public void doSecond() {
	}
}

3)代理类

package com.gavin.service;

public class SomeServiceProxy implements ISomeService {

	@Override
	public String doFirst() {
		ISomeService target = new ISomeServiceImpl();
		String result = target.doFirst();
		return result.toUpperCase();
	}

	@Override
	public void doSecond() {
		
	}

}

4)测试类

package com.gavin.test;

import com.gavin.service.ISomeService;
import com.gavin.service.SomeServiceProxy;

public class MyTest {
	public static void main(String[] args) {
		ISomeService service = new SomeServiceProxy();
		String result = service.doFirst();
		System.out.println("result :" + result);
	}
}

总结:

   静态代理模式就是本来一个实现类就这样运行，但是通过一个代理类就把他间接在代理类内部实现增强了，所以在需要的时候就变了。但也缺点，就是目标类很多，就会使代码变得累赘。增加维护成本。

<2>JDK动态代理

   通过JDK自带得方法来实现代理，但是目标类不能实现接口

   代码示例：

在测试类实现JDK动态代理

package com.gavin.test;

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

import com.gavin.service.ISomeService;
import com.gavin.service.SomeServiceImpl;

/**
 * 此类是测试JDK动态代理的测试
 * @author Gavin
 *
 */
public class Test {

	public static void main(String[] args) {
		//使用JDK动态代理时，必须实现目标类接口
		//因为其底层实现流程和静态代理是一致的
		SomeServiceImpl target = new SomeServiceImpl();
		ISomeService iSomeService = (ISomeService) Proxy.newProxyInstance(
				target.getClass().getClassLoader(),//加载类类加载器
				target.getClass().getInterfaces(),//获取被代理类的所有接口信息
				new InvocationHandler() {
					/*
				        proxy 代理对象
					method 目标方法
					args 参数
					*/
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						// TODO Auto-generated method stub
						Object result = method.invoke(target, args);
						if (result != null) {
							result = ((String) result).toUpperCase();
						}
						return result;
					}
				});
		String result = iSomeService.doSecond();
		System.out.println(result);
	}
}

2)目标类

package com.gavin.service;

public class SomeServiceImpl implements ISomeService{

	@Override
	public void doFirst() {
		// TODO Auto-generated method stub
	}

	@Override
	public String doSecond() {
		// TODO Auto-generated method stub
		System.out.println("执行doSecond()");
		return "abcde";
	}

}

3)必须要实现得接口

package com.gavin.service;

public interface ISomeService {
	void doFirst();
	String doSecond();
}

ps：一定要实现接口

<3>Cglib动态代理

  通过第三方工具实现动态代理，所需JAR包已经在前面写出

  代码示例

1)代理工厂

package com.gavin.Factory;

import java.lang.reflect.Method;

import com.gavin.service.SomeService;

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

public class CglibFactory implements MethodInterceptor{
	
	public SomeService myCglibCreator(){
		//创建增强器对象
	    Enhancer enhancer = new	Enhancer();
	    //指定目标类 即父类
	    enhancer.setSuperclass(SomeService.class);
	    //设置回调接口对象
	    enhancer.setCallback(this);
		return (SomeService) enhancer.create();
	}

	@Override
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        SomeService someService = new SomeService();
		Object result = method.invoke(someService, args);
		if (result != null) {
			result = ((String) result).toUpperCase();
		}
		return result;
	}
}

package com.gavin.test;
//测试类
import com.gavin.Factory.CglibFactory;
import com.gavin.service.SomeService;

public class MyTest {
	public static void main(String[] args) {
		SomeService service = new CglibFactory().myCglibCreator();
		System.out.println(service.doFirst());
	}
}

3)目标类

package com.gavin.service;

public class SomeService {
	
	public String doFirst() {
		return "abcde";
	}
	
	public void doSecond() {
	}
}

总结:

  既能代理又接口的目标类，又能实现没有接口的类，有接口的情况可以自己修改即可

总的来说，增强一个类，就有三种途径，视情况考虑

适配器模式

 在这里没有作详细的总结 就贴出比较经典的总结

http://www.cnblogs.com/java-my-life/archive/2012/04/13/2442795.html

模板方法

https://www.cnblogs.com/meet/p/5116417.html