J2EE常用设计模式

单例模式：保证内存中只有一个对象

饿汉式：

package com.westos.moshi.danli;

//饿汉式
public class Ehanshi {

	private static Ehanshi ehanshi = new Ehanshi();// 创建自己的对象

	private Ehanshi() {// 私有化构造

	}

	public static Ehanshi getEhanshi() {// 公共方法返回对象
		return ehanshi;

	}

}

package com.westos.moshi.test;

import com.westos.moshi.danli.Ehanshi;
//单例模式饿汉式
public class Test1 {
		public static void main(String[] args) {
			Ehanshi ehanshi = Ehanshi.getEhanshi();
			Ehanshi ehanshi2 = Ehanshi.getEhanshi();
			System.out.println(ehanshi==ehanshi2);
			//测试结果为TRUE，说明只能得到一个对象，即为单例模式
		}
}

懒汉式：

package com.westos.moshi.danli;
//懒汉式
public class Lanhanshi {
	private static Lanhanshi lanhanshi = null;

	private Lanhanshi() {// 私有化构造

	}

	public synchronized static Lanhanshi getLanhanshi() {//提供公共静态方法
		if (lanhanshi == null) {
			new Lanhanshi();
		}
		return lanhanshi;

	}
}

package com.westos.moshi.test;

import com.westos.moshi.danli.Lanhanshi;

public class Test2 {
		public static void main(String[] args) {
			Lanhanshi lanhanshi = Lanhanshi.getLanhanshi();
			Lanhanshi lanhanshi2=Lanhanshi.getLanhanshi();
			System.out.println(lanhanshi==lanhanshi2);
			//测试结果为TRUE
		}
}

适配器模式：

把一个类的接口变换成为客户端所期待的另外一种接口，从而使原来因接口不匹配而无法在一起工作的两个类能够在一起工作

package com.westos.moshi.shipeiqi;
// 适配器目标
public interface ShipeiqiTarget {
	
	void dianya12v();
	void leixing();
}

package com.westos.moshi.shipeiqi;

public class ShipeiqiAdaptee {
		public void dianya220v() {
			System.out.println("这是220v的电压");
		}
		public void jiekouleixing() {
			System.out.println("这是一个三项接口");
		}
}

package com.westos.moshi.shipeiqi;
//适配器
public class Adapter extends ShipeiqiAdaptee implements ShipeiqiTarget{

	@Override
	public void dianya12v() {
		dianya220v();
		System.out.println("适配器进行了电压转换为12v");
		
	}

	@Override
	public void leixing() {
		jiekouleixing();
		System.out.println("适配器进行了类型转换为leixing");
		
	}

}

package com.westos.moshi.shipeiqi;
//缺省适配器模式
public class NewAdapter implements ShipeiqiTarget{
	
		private ShipeiqiAdaptee shipeiqiAdaptee;
		
		public NewAdapter(ShipeiqiAdaptee adaptee) {
			this.shipeiqiAdaptee=adaptee;
		}
		
		@Override
		public void dianya12v() {
			this.shipeiqiAdaptee.dianya220v();;
			System.out.println("新适配器的电压转换为12v");
		}

		@Override
		public void leixing() {
			this.shipeiqiAdaptee.jiekouleixing();
			System.out.println("新适配器的电压转换为leixing");
			
		}
}

package com.westos.moshi.shipeiqi;
//测试类
public class Client {
		public static void main(String[] args) {
			ShipeiqiTarget adapter = new Adapter();
			adapter.dianya12v();
			adapter.leixing();
			System.out.println("-------------------------");
			ShipeiqiAdaptee adaptee = new ShipeiqiAdaptee();
			NewAdapter newAdapter = new NewAdapter(adaptee);
			newAdapter.dianya12v();
			newAdapter.leixing();
			
		}
}

结果为：

这是220v的电压
适配器进行了电压转换为12v
这是一个三项接口
适配器进行了类型转换为leixing
-------------------------
这是220v的电压
新适配器的电压转换为12v
这是一个三项接口
新适配器的电压转换为leixing

合成模式：

合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式可以使客户端将单纯元素与复合元素同等对待

package com.westos.moshi.hecheng;

public interface IFile {
		void printname();
		boolean isdir();
}

package com.westos.moshi.hecheng;
//文件
public class MyFile implements IFile{
	
	private String name;
	
	public MyFile(String filename) {
		this.name = filename;
	}

	@Override
	public void printname() {
		System.out.println("文件的名字是："+this.name);
	}

	@Override
	public boolean isdir() {
		
		return false;
	}
}

package com.westos.moshi.hecheng;
//文件夹
import java.util.ArrayList;
import java.util.List;

public class MyDir implements IFile{

	private List<IFile> filelist;
	private String name;
	
	public MyDir(String dirname) {
	this.filelist = new ArrayList<>();
	this.name = dirname;
	}
	@Override
	public void printname() {
		System.out.println("文件夹的名字是："+this.name);
		System.out.println("文件夹下的文件有：");
		for(IFile f:filelist){
			f.printname();
		}
	}
	@Override
	public boolean isdir() {
		
		return true;
	}
	public List<IFile> getFilelist() {
		return filelist;
	}
	public void setFilelist(List<IFile> filelist) {
		this.filelist = filelist;
	}
	

}

package com.westos.moshi.hecheng;
//测试类
import java.util.ArrayList;
import java.util.List;

public class Client {
	public static void main(String[] args) {
		
		MyDir myDir1 = new MyDir("文件夹1");
		MyFile myFile1 = new MyFile("文件1");
		MyFile myFile2 = new MyFile("文件2");
		MyFile myFile3 = new MyFile("文件3");
		
		MyDir myDir2 = new MyDir("文件夹2");
		MyFile myFile4 = new MyFile("文件4");
		MyFile myFile5 = new MyFile("文件5");
		MyFile myFile6 = new MyFile("文件6");
		
		List<IFile> filelist = new ArrayList<>();
		filelist.add(myFile1);
		filelist.add(myFile2);
		filelist.add(myFile3);
		List<IFile> filelist2 = new ArrayList<>();
		filelist2.add(myFile4);
		filelist2.add(myFile5);
		filelist2.add(myFile6);
		filelist2.add(myDir1);
		myDir1.setFilelist(filelist);
		myDir2.setFilelist(filelist2);
		myDir1.printname();
		myDir2.printname();
	}
}

 测试结果：

文件夹的名字是：文件夹1
文件夹下的文件有：
文件的名字是：文件1
文件的名字是：文件2
文件的名字是：文件3
文件夹的名字是：文件夹2
文件夹下的文件有：
文件的名字是：文件4
文件的名字是：文件5
文件的名字是：文件6
文件夹的名字是：文件夹1
文件夹下的文件有：
文件的名字是：文件1
文件的名字是：文件2
文件的名字是：文件3

策略模式：

将每一组算法封装到具有共同接口的独立的类中，从而使得他们可以相互替换。策略模式可以使算法可以在不影响到客户端的情况下发生变化

package com.westos.moshi.celue;

public interface Celue {
		void paixu();
}

package com.westos.moshi.celue;

public class Maopao implements Celue{

	@Override
	public void paixu() {
		System.out.println("这是冒泡法排序");
		
	}

}

package com.westos.moshi.celue;

public class Erfenfa implements Celue{

	@Override
	public void paixu() {
		System.out.println("使用二分法排序");
		
	}

}

package com.westos.moshi.celue;

public class Context {
	private Celue celue;
	public Context (Celue c) {
		this.celue=c;
	}
	public void method() {
		celue.paixu();
	}
	public Celue getCelue() {
		return celue;
	}
	public void setCelue(Celue celue) {
		this.celue = celue;
	}
}

package com.westos.moshi.celue;

public class Client {
		public static void main(String[] args) {
			Maopao m = new Maopao();
			Context context = new Context(m);
			context.method();
			Erfenfa e = new Erfenfa();
			context.setCelue(e);
			context.method();
		}
}

这是冒泡法排序
使用二分法排序

代理模式：

在方法执行前和执行后插入语句

1.

package com.westos.moshi.daili;

public interface Subject {
	void request();
}

package com.westos.moshi.daili;
//真实主体
public class RealSubject implements Subject{

	@Override
	public void request() {
		System.out.println("发起http请求");
		
	}

}

package com.westos.moshi.daili;
//代理主体
public class ProxySubject implements Subject{
	private Subject realsubject;
	public ProxySubject(Subject s) {
		this.realsubject=s;
	}

	@Override
	public void request() {
		System.out.println("方法执行前。。");
		this.realsubject.request();
		System.out.println("方法执行后。。。");
		
	}

}

package com.westos.moshi.daili;
//测试类
public class Client1 {
		public static void main(String[] args) {
			Subject realSubject = new RealSubject();
			ProxySubject proxySubject = new ProxySubject(realSubject);
			proxySubject.request();
		}
}

测试结果：

方法执行前。。
发起http请求
方法执行后。。。

2.

package com.westos.moshi.daili;

public interface Subject {
	void request();
}

package com.westos.moshi.daili;

public class RealSubject implements Subject{

	@Override
	public void request() {
		System.out.println("发起http请求");
		
	}

}

package com.westos.moshi.daili;

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

public class ProxyHandler implements InvocationHandler{

	private Object realobj;
	
	public ProxyHandler (Object obj) {
		this.realobj=obj;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("ProxyHandler方法执行前。。"+method.getName());
		Object result = method.invoke(realobj, args);
		System.out.println("ProxyHandler方法执行后。。。"+method.getName());
		return result;
	}

}

package com.westos.moshi.daili;

import java.lang.reflect.Proxy;

public class Client2 {
	public static void main(String[] args) {
		RealSubject realSubject = new RealSubject();
		Subject proxy = (Subject) Proxy.newProxyInstance(
				Subject.class.getClassLoader(),
				new Class[] {Subject.class}, //最好写成接口
				new ProxyHandler(realSubject)
				);
		System.out.println(proxy.getClass().getName());
		proxy.request();
		
	}
}

结果：

ProxyHandler方法执行前。。request
发起http请求
ProxyHandler方法执行后。。。request

3.

package com.westos.moshi.daili;

public interface Subject {
	void request();
}

package com.westos.moshi.daili;

public interface IHello {
	String sayhello(String name);
}

package com.westos.moshi.daili;


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


public class Dongtaidaili implements InvocationHandler{


	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("Dongtaidaili方法执行前");
		String methodname = method.getName();
		String classname = method.getDeclaringClass().getName();
		System.out.println(methodname);
		System.out.println(classname);
		if("request".equals(methodname)) {
			System.out.println("动态代理自己实现的http请求");
		}if("sayhello".equals(methodname)){
			return "你好"+args[0];
		}
		System.out.println("Dongtaidaili方法执行后");
		return null;
	}


}

package com.westos.moshi.daili;

import java.lang.reflect.Proxy;

public class Client3 {
	public static void main(String[] args) {
		Subject proxy = (Subject) Proxy.newProxyInstance(
				Subject.class.getClassLoader(),
				new Class[] {Subject.class}, 
				new Dongtaidaili()
				);
		proxy.request();
		IHello proxy2 = (IHello) Proxy.newProxyInstance(
				IHello.class.getClassLoader(),
				new Class[] {IHello.class}, 
				new Dongtaidaili()
				);
		System.out.println(proxy2.sayhello("bear"));
	}
}

结果：

Dongtaidaili方法执行前
request
com.westos.moshi.daili.Subject
动态代理自己实现的http请求
Dongtaidaili方法执行后
Dongtaidaili方法执行前
sayhello
com.westos.moshi.daili.IHello
你好bear