CGlib动态代理CallbackFilter

1、Car.java

package com.ast.cglib.test;

public class Car {

}

2、Truck.java

package com.ast.cglib.test;

public class Truck extends Car{

}

3、MyInterceptor.java

package com.ast.cglib.test;

import java.lang.reflect.Method;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class MyInterceptor implements MethodInterceptor{

	@Override
	public Object intercept(Object invoker, Method method, Object[] args,
			MethodProxy proxy) throws Throwable {
		
		System.out.println("NewCarInterceptor intercept before invoke");
		
		Object result = proxy.invokeSuper(invoker, args);
		
		System.out.println("NewCarInterceptor intercept after invoke");
		
		return result;
	}

}

4、MyCallbackFilter.java

package com.ast.cglib.test;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.CallbackFilter;

public class MyCallbackFilter implements CallbackFilter {
	
	public int accept(Method method) {
		if (method.getName().equals("NewTruck")) {
			return 0;
		} else {
			return 1;
		}
	}
}

5、CarFactory.java

package com.ast.cglib.test;

import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.NoOp;

public class CarFactory{
	public Car NewCar()
	{
		System.out.println("CarFactory NewCar");
		return new Car();
	}
	
	public Truck NewTruck()
	{
		System.out.println("CarFactory NewTruck");
		return new Truck();
	}
	
	public static void EnhancerTest()
	{
		Callback[] callbacks = new Callback[] {new MyInterceptor(),  NoOp.INSTANCE};
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(CarFactory.class);
		enhancer.setCallbacks(callbacks);
		enhancer.setCallbackFilter(new MyCallbackFilter());
		
		CarFactory fac = (CarFactory)enhancer.create();
		//NoOp
		fac.NewCar();
		//MyInterceptor
		fac.NewTruck();
	}
	
	public static void main(String[] args)
	{
		CarFactory.EnhancerTest();
	}
}

CGlib类型整合范例Mixin

1、IA1.java

package com.ast.cglib.test;

public interface IA1 {
	void methodA1();
}

2、IA2.java

package com.ast.cglib.test;

public interface IA2 {
	void methodA2();
}

3、A1Impl.java

package com.ast.cglib.test;

public class A1Impl implements IA1{

	@Override
	public void methodA1() {
		System.out.println("A1Impl methodA1");
	}

}

4、A2Impl.java

package com.ast.cglib.test;

public class A2Impl implements IA2{

	@Override
	public void methodA2() {
		System.out.println("A2Impl methodA2");
	}

}

5、MixinTest.java

package com.ast.cglib.test;

import net.sf.cglib.proxy.Mixin;

public class MixinTest {
	public static void main(String[] args) {

		Class[] interfaces = new Class[] { IA1.class, IA2.class };

		Object[] delegates = new Object[] { new A1Impl(), new A2Impl() };

		Object obj = Mixin.create(interfaces, delegates);

		IA1 a1 = (IA1) obj;
		a1.methodA1();

		IA2 a2 = (IA2) obj;
		a2.methodA2();
	}
}

CGlib动态代理范例

1、ProxyFactory.java

package com.ats.proxy;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

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

public class ProxyFactory implements MethodInterceptor{
	//private Object invoker;
	private List<Object> interceptors;
	
	private ProxyFactory(Object invoker,List<Object> interceptors)
	{
		//this.invoker = invoker;
		if(interceptors==null)
		{
			this.interceptors = new ArrayList<Object>();
		}
		else
		{
			this.interceptors = interceptors;
		}
	}
	
	 public static final Object newInstance(Object invoker,List<Object> interceptors)
	 {
		 Enhancer enhancer = new Enhancer();
		 enhancer.setSuperclass(invoker.getClass());
		 enhancer.setCallback(new ProxyFactory(invoker,interceptors));
		 return enhancer.create();
	 }
	
	@Override
	public Object intercept(Object invoker, Method method, Object[] args,
			MethodProxy proxy) throws Throwable {
		
		Object result = null;
		
		for(Object o : interceptors)
		{
			if(o instanceof IProxyBefore)
			{
				((IProxyBefore)o).BeforeInvoke();
			}
		}
		
		try
		{
			result = proxy.invokeSuper(invoker, args);
		}
		catch(Exception ex)
		{
			for(Object o : interceptors)
			{
				if(o instanceof IProxyThrow)
				{
					((IProxyThrow)o).ThrowInvoke();
				}
			}
		}
		
		for(Object o : interceptors)
		{
			if(o instanceof IProxyAfter)
			{
				((IProxyAfter)o).AfterInvoke();
			}
		}
		
		return result;
	}
}

2、IProxyBefore.java

package com.ats.proxy;

public interface IProxyBefore {
	public void BeforeInvoke();
}

3、IProxyAfter.java

package com.ats.proxy;

public interface IProxyAfter {
	public void AfterInvoke();
}

4、IProxyAround.java

package com.ats.proxy;

public interface IProxyAround extends IProxyBefore,IProxyAfter{
}

5、IProxyThrow.java

[code lang="java"]
package com.ats.proxy;

public interface IProxyThrow {
	public void ThrowInvoke();
}

6、Car.java

package com.ats.test;

public class Car {
	public Car()
	{
		System.out.println("This is a new Car");
	}
}

7、CarFactoryBefore.java

package com.ats.test;

import com.ats.proxy.IProxyBefore;

public class CarFactoryBefore implements IProxyBefore{

	@Override
	public void BeforeInvoke() {
		System.out.println("CarFactoryBefore BeforeInvoke");
	}

}

8、CarFactoryAfter.java

package com.ats.test;

import com.ats.proxy.IProxyAfter;

public class CarFactoryAfter implements IProxyAfter {

	@Override
	public void AfterInvoke() {
		System.out.println("CarFactoryAfter AfterInvoke");
	}

}

9、CarFactoryAround.java

package com.ats.test;

import com.ats.proxy.IProxyAround;

public class CarFactoryAround implements IProxyAround{
	@Override
	public void AfterInvoke() {
		System.out.println("CarFactoryAround AfterInvoke");
	}
	
	@Override
	public void BeforeInvoke() {
		System.out.println("CarFactoryAround BeforeInvoke");
	}
}

10、CarFactoryThrow.java

package com.ats.test;

import com.ats.proxy.IProxyThrow;

public class CarFactoryThrow implements IProxyThrow {
	@Override
	public void ThrowInvoke() {
		System.out.println("CarFactory ThrowInvoke");
	}
}

11、ProxyFactory.java

package com.ats.test;

import java.util.ArrayList;
import java.util.List;

import com.ats.proxy.ProxyFactory;

public class CarFactory{
	public Car NewCar()
	{
		return new Car();
	}
	
	public static void main(String[] args)
	{
		CarFactory fac = new CarFactory();
		CarFactoryAfter after = new CarFactoryAfter();
		CarFactoryBefore before = new CarFactoryBefore();
		CarFactoryAround around = new CarFactoryAround();
		CarFactoryThrow _throw = new CarFactoryThrow();
		List<Object> l = new ArrayList<Object>();
		l.add(after);
		l.add(before);
		l.add(around);
		l.add(_throw);
		
		CarFactory fac1=(CarFactory)ProxyFactory.newInstance(fac, l);
		fac1.NewCar();
	}
}

JDK动态代理范例

1、ProxyFactory.java

package com.ats.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class ProxyFactory implements InvocationHandler{
	private Object invoker;
	private List<Object> interceptors;
	
	private ProxyFactory(Object invoker,List<Object> interceptors)
	{
		this.invoker = invoker;
		if(interceptors==null)
		{
			this.interceptors = new ArrayList<Object>();
		}
		else
		{
			this.interceptors = interceptors;
		}
	}
	
    public static final Object newInstance(Object invoker,List<Object> interceptors)
    {
        return java.lang.reflect.Proxy.newProxyInstance(invoker.getClass().getClassLoader(),
        		invoker.getClass().getInterfaces(), new ProxyFactory(invoker,interceptors));
    }
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = null;
		
		for(Object o : interceptors)
		{
			if(o instanceof IProxyBefore)
			{
				((IProxyBefore)o).BeforeInvoke();
			}
		}
		
		try
		{
			result = method.invoke(invoker, args);
		}
		catch(Exception ex)
		{
			for(Object o : interceptors)
			{
				if(o instanceof IProxyThrow)
				{
					((IProxyThrow)o).ThrowInvoke();
				}
			}
		}
		
		for(Object o : interceptors)
		{
			if(o instanceof IProxyAfter)
			{
				((IProxyAfter)o).AfterInvoke();
			}
		}
		return result;
	}
}

2、IProxyBefore.java

package com.ats.proxy;

public interface IProxyBefore {
	public void BeforeInvoke();
}

3、IProxyAfter.java

package com.ats.proxy;

public interface IProxyAfter {
	public void AfterInvoke();
}

4、IProxyAround.java

package com.ats.proxy;

public interface IProxyAround extends IProxyBefore,IProxyAfter{
}

5、IProxyThrow.java

package com.ats.proxy;

public interface IProxyThrow {
	public void ThrowInvoke();
}

6、ICarFactory.java

package com.ats.test;

public interface ICarFactory {
	public Car NewCar();
}

7、Car.java

package com.ats.test;

public class Car {
	public Car()
	{
		System.out.println("This is a new Car");
	}
}

8、IProxyBefore.java

package com.ats.test;

import com.ats.proxy.IProxyBefore;

public class CarFactoryBefore implements IProxyBefore{

	@Override
	public void BeforeInvoke() {
		System.out.println("CarFactoryBefore BeforeInvoke");
	}

}

9、CarFactoryAfter.java

package com.ats.test;

import com.ats.proxy.IProxyAfter;

public class CarFactoryAfter implements IProxyAfter {

	@Override
	public void AfterInvoke() {
		System.out.println("CarFactoryAfter AfterInvoke");
	}

}

10、CarFactoryAround .java

package com.ats.test;

import com.ats.proxy.IProxyAround;

public class CarFactoryAround implements IProxyAround{
	@Override
	public void AfterInvoke() {
		System.out.println("CarFactoryAround AfterInvoke");
	}
	
	@Override
	public void BeforeInvoke() {
		System.out.println("CarFactoryAround BeforeInvoke");
	}
}

11、CarFactoryThrow.java

package com.ats.test;

import com.ats.proxy.IProxyThrow;

public class CarFactoryThrow implements IProxyThrow {
	@Override
	public void ThrowInvoke() {
		System.out.println("CarFactory ThrowInvoke");
	}
}

12、CarFactory.java

package com.ats.test;

import java.util.ArrayList;
import java.util.List;

import com.ats.proxy.IProxyAround;
import com.ats.proxy.IProxyThrow;
import com.ats.proxy.ProxyFactory;

public class CarFactory implements ICarFactory {
	public Car NewCar()
	{
		return new Car();
	}
	
	public static void main(String[] args)
	{
		CarFactory fac = new CarFactory();
		CarFactoryAfter after = new CarFactoryAfter();
		CarFactoryBefore before = new CarFactoryBefore();
		CarFactoryAround around = new CarFactoryAround();
		CarFactoryThrow _throw = new CarFactoryThrow();
		List<Object> l = new ArrayList<Object>();
		l.add(after);
		l.add(before);
		l.add(around);
		l.add(_throw);
		
		ICarFactory factory = (ICarFactory)ProxyFactory.newInstance(fac,l);
		factory.NewCar();
	}
}

CMD常用命令12切换网络

1、切换为DHCP

@netsh interface ip set address name="本地连接" source=dhcp

@netsh interface ip set dns name="本地连接" source=dhcp

2、切换为静态IP

@netsh interface ip set address name="本地连接" source=static addr=xxx.xxx.xxx.xxx mask=255.255.255.0 gateway=xxx.xxx.xxx.xxx

@netsh interface ip set dns name="本地连接" source=static addr=xxx.xxx.xxx.xxx

设计模式笔记

设计模式
1、设计模式原则
开放封闭原则:一个类,对修改封闭,对扩展开放
依赖反转原则:依赖于抽象而不是具体实现,实现依赖接口,接口不依赖于实现
迪米特法则:尽量减少与其他类的关系,降低类之间耦合度
里氏转换原则:子类必须能替代父类
接口隔离原则:类的依赖建立在最小接口之上,多个小接口优于一个大接口
合成复用原则:聚合优先于继承

2、简单工厂
将创建实例的代码,集中到一个类中,实现一个类创建多种实例。

3、工厂模式
将创建实例的代码,在工厂子类中实现,调用者负责使用哪个工厂。

4、抽象工厂
将工厂抽象为一系列的接口,在每个工厂子类中,用工厂方法实现这些接口。

5、模板方法
创建对象的步骤固定,每个步骤都放到子类中实现。

6、生成器
创建对象的步骤不固定,但组件固定,可以方便的增加各种组件。

7、策略模式
多种算法,在使用时,指定选用的算法。

8、状态模式
多种算法,根据对象的状态,选用对应的算法。

9、装饰者
包装现有对象,增加功能。

10、外观
将一系列复杂接口,重新组成一个简单的接口。

11、迭代器
不暴露细节的前提下,提供遍历
Java、DotNet
12、组合
对象和组,采用相同的方式来实现
菜单
13、代理
提供代理类,间接访问对象,提供访问控制,调用者不知道被代理类的存在
远程代理,虚拟代理
14、桥接
采用桥接类,利用组合访问的方式,处理桥接对象之间的访问

15、适配器
封装原有接口,成为新接口

16、观察者
对象状态改变,通知其他对象

17、访问者
不改变原来实现的前提下,通过访问者,提供新功能(破坏封装)

18、中介者
多个对象之间的访问,改变为对象与中介者之间的访问

19、命令
将请求封装为对象,可以回滚

20、备忘录
记录状态,随时回滚

21、单件
最多只有一个实例

22、蝇量(享元)
同一类的大量实例,共享存储

23、原型
复制复杂对象,而并非重新创建对象

24、解释器
嵌入式语言

25、责任链
消息响应链

26、组合模式
MVC等

好书推荐:
《Head First设计模式》、《大话设计模式》、《23种设计模式》

自签名证书HTTPS

1、生成自签名的CA私钥及自签名证书,并导出为der、p12、jks格式

set OPENSSL_CONF=C:\ProgramerTools\OpenSSL-Win64\bin\openssl.cfg

#生成私钥
openssl genrsa 1024 > NMyCA1024.key

#生成自签名证书
openssl req -new -x509 -nodes -key NMyCA1024.key -days 1095 -subj "/C=CN/ST=ShangHai/L=ShangHai/O=NEOHOPE/OU=Development/CN=NMyCA1024" > NMyCA1024.pem

#转der格式,生成trust store
openssl x509 -outform der -in NMyCA1024.pem -out NMyCA1024.crt
keytool -import -trustcacerts -file NMyCA1024.crt -keystore NMyCA1024_trust.jks -storepass 123456

#转p12格式,生成key sotre
openssl pkcs12 -export -out NMyCA1024.p12 -in NMyCA1024.pem -inkey NMyCA1024.key
keytool -importkeystore -srckeystore NMyCA1024.p12 -srcstoretype PKCS12 -deststoretype  JKS -destkeystore NMyCA1024_key.jks

2、生成网站私钥,并生成CA签名的证书,并导出为der、p12、jks格式

#生成私钥
openssl genrsa 1024 > server.key

#从CA请求证书
openssl req -new -key server.key -subj "/C=CN/ST=ShangHai/L=ShangHai/O=NEOHOPE/OU=Development/CN=127.0.0.1" > server.csr

#生成CA签名的证书
openssl x509 -req -in server.csr -CA NMyCA1024.pem -CAkey NMyCA1024.key -CAcreateserial -days 365 > serversigned.crt

#生成trust store
keytool -import -trustcacerts -file serversigned.crt -keystore serversigned_trust.jks -storepass 123456

#转p12格式,生成key sotre
openssl pkcs12 -export -out serversigned.p12 -in serversigned.crt -inkey server.key
keytool -importkeystore -srckeystore serversigned.p12 -srcstoretype PKCS12 -deststoretype  JKS -destkeystore serversigned_key.jks

3、在server端使用serversigned.p12或serversigned_key.jks

4、在浏览器端,导入NMyCA1024.crt为CA根证书,浏览器就可以正常打开HTTPS网站了

5、如果是要用Java Client端进行认证,则需要将CA证书导入到对应JDK或JRE的CA列表中,用serversigned_trust.jks就可以正常访问了

keytool -import -trustcacerts -file NMyCA1024.crt -alias NMyCA1024 -keystore %JRE_HOME%\lib\security\cacerts -storepass changeit

openssl获取网站证书及验证证书链

1、获取网站证书信息

set OPENSSL_CONF=C:\ProgramerTools\OpenSSL-Win64\bin\openssl.cfg
#获取淘宝证书信息
openssl s_client -showcerts -connect www.taobao.com:443
#获取淘宝ssl2证书信息
openssl s_client -showcerts -ssl2 -connect www.taobao.com:443

2、验证证书链
比如,我有一个自签名的三层证书系统:
NMyCA1024(RootCA,自签名认证)
NMySubCA1024(NMySubCA1024是是中级CA,是NMyCA1024认证过的)
Server(Server是服务器证书,是NMySubCA1024认证过的)

可以用如下方法验证证书链:

#会告诉你这是一个自签名证书
openssl verify NMyCA1024.pem

#L1中方的是NMyCA1024的证书
openssl verify -CAfile L1.pem NMySubCA1024.pem

#L2中方的是NMyCA1024及NMySubCA1024的证书
openssl verify -CAfile L2.pem Server.pem

#只用中级证书,会导致证书链不完整,无法通过验证
openssl verify -CAfile NMySubCA1024.pem Server.pem

JKS密码验证

下面的程序用来验证JKS的文件及密码是否正确

public static URL getStoreURL(String storePath) throws IOException
{
	URL url = null;
	// First see if this is a URL
	try
	{
		url = new URL(storePath);
	}
	catch (MalformedURLException e)
	{
		// Not a URL or a protocol without a handler so...
		// next try to locate this as file path
		File tst = new File(storePath);
		if (tst.exists() == true)
		{
			url = tst.toURL();
		} else
		{
			// not a file either, lastly try to locate this as a classpath
			// resource
			if (url == null)
			{
				ClassLoader loader = Thread.currentThread().getContextClassLoader();
				url = loader.getResource(storePath);
			}
		}
	}
	// Fail if no valid key store was located
	if (url == null)
	{
		String msg = "Failed to find url=" + storePath + " as a URL, file or resource";
		throw new MalformedURLException(msg);
	}
	return url;
}

public static KeyStore loadKeyStore(String storeType, URL storePathURL, String storePassword) throws Exception
{
	KeyStore keyStore = null;
	String provider = null;
	String providerName = null;

	if (provider != null)
	{
		keyStore = KeyStore.getInstance(storeType, provider);
	} else
		if (providerName != null)
		{
			keyStore = KeyStore.getInstance(storeType, providerName);
		} else
		{
			keyStore = KeyStore.getInstance(storeType);
		}
	if (storePathURL == null) { throw new Exception("Can not find store file for url because store url is null."); }
	// now that keystore instance created, need to load data from file
	InputStream keyStoreInputStream = null;
	try
	{
		keyStoreInputStream = storePathURL.openStream();
		// is ok for password to be null, as will just be used to check
		// integrity of store
		char[] password = storePassword != null ? storePassword.toCharArray() : null;
		keyStore.load(keyStoreInputStream, password);
	}
	finally
	{
		if (keyStoreInputStream != null)
		{
			try
			{
				keyStoreInputStream.close();
			}
			catch (IOException e)
			{
				// no op
			}
			keyStoreInputStream = null;
		}
	}
	return keyStore;
}

public static String verifyP12(String p12Path,String p12Pwd)
{
            String ret = "验证成功";
            try
            {
	URL ksURL = getStoreURL(p12Path);
                if(ksURL==null)throw new Exception(p12Path+"文件未找到");
                    
	loadKeyStore("PKCS12",ksURL,p12Pwd);
            }
            catch(Exception ex)
            {
                ret = ex.getMessage();
                ex.printStackTrace();
            }
            return ret;
}

public static String verifyJks(String jksPath,String jksPwd)
{
            String ret = "验证成功";
            try
            {
	URL ksURL = getStoreURL(jksPath);
	loadKeyStore("JKS",ksURL,jksPwd);
                
                if(ksURL==null)throw new Exception(jksPath+"文件未找到");
            }
            catch(Exception ex)
            {
                ret = ex.getMessage();
                ex.printStackTrace();
            }
            
            return ret;
}