1、查看设备是否存在
#执行发现设备不存在 ls /dev | grep mpt mpt-status #新建设备 mknod /dev/mptctl c 10 220
2、手动加载模块
modeprobe mptctl lsmod | grep mpt
3、自动加载模块
编辑/etc/moduels，增加一行
mptctl
4、重启搞定
Author Archives: neohope
VMWare扩展及压缩虚拟磁盘
1、扩展虚拟磁盘
1.1A我的xp虚拟机一共只有10G，我需要扩展到20G（要关虚拟机）
"D:\Program files\VMware\VMware Workstation\vmware-vdiskmanager.exe" -x 20GB "D:\VirtualMashines\VMware\WinXP\WinXP.vmdk"
1.1BVMWare10以后，可以直接在管理工具中
虚拟机-》设置-》硬盘-》实用工具-》扩展
1.2扩展后，开启虚拟机，自己到磁盘管理器中分配空间即可。
2、压缩WinXP虚拟磁盘（vmware-tools）
2.1管理工具（关闭虚拟机）
虚拟机-》设置-》硬盘-》实用工具-》碎片整理
2.2开启虚拟机
系统托盘图标-》vmware-tools-》压缩
3、压缩WinXP虚拟磁盘（vmware-vdiskmanager）
3.1需要到微软官网下载sdelete工具，然后在虚拟机中运行：
sdelete -z
3.2关闭虚拟机，运行：
"D:\Program files\VMware\VMware Workstation\vmware-vdiskmanager.exe" -k "D:\VirtualMashines\VMware\WinXP\WinXP.vmdk"
4、压缩Debian虚拟磁盘：
4.1A在虚拟机中运行zerofree命令，需要将分区挂载为只读模式
apt-get install zerofree umount /etc/home zerofree /dev/sda6
4.1B在虚拟机中运行dd命令，需要将分区挂载为读写模式
dd if=/dev/zero of=/bigemptyfile rm bigemptyfile
4.2关闭虚拟机，运行：
"D:\Program files\VMware\VMware Workstation\vmware-vdiskmanager.exe" -k "D:\VirtualMashines\VMware\Debian8\Debian8.vmdk"
5、压缩FreeBSD虚拟磁盘：
5.1A在虚拟机中运行dd命令，需要将分区挂载为读写模式
dd if=/dev/zero of=bigemptyfile bs=1m rm bigemptyfile
5.1B在虚拟机中运行dd命令，需要将分区挂载为读写模式（适用于影片空闲空间较小）
cat /dev/zero > bigemptyfile;sync;sleep 1;sync; rm -f bigemptyfile
5.2关闭虚拟机，运行：
"D:\Program files\VMware\VMware Workstation\vmware-vdiskmanager.exe" -k "D:\VirtualMashines\VMware\FreeBSD10\Debian8.vmdk"
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
CMD常用命令11获取上一次命令行执行结果
获取上一次执行结果：
Linux:
echo $?
Win:
echo %ERRORLEVEL%
设计模式笔记
设计模式
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