jdk动态代理是java.lang.reflect.*包提供的方式，它必须借助一个接口才能 产生代理对象，通过动态代理技术，我们可以在调用一个对象的某个函数之前 插入一个新的服务，或者在之后插入一个新的服务,即它可以通过在不该变一个类 的源代码的情况下，为该类添加新的函数功能。
interface HelloWorld{
public void sayHelloWorld();
}
public class HelloWorldImpl implements HelloWorld{
@Override
public void sayHelloWorld(){
System.out.println("Hello World!");
}
}public class JdkProxyExample implements InvocationHandler {
//真实对象
private Object target=null;
/**
* 建立代理对象和真实对象的代理关系，并返回代理对象
* @param target 真是对象
* @return 代理对象
*/
public Object bind(Object target){
this.target=target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
/**
* 代理方法的逻辑
* @param proxy 代理对象
* @param method
* @param args
* @return
*/
@Override
public Object invoke(Object proxy, Method method,Object[] args)throws Throwable{
System.out.println("进入代理对象的逻辑方法");
System.out.println("在调度真实对象之前的服务");
Object obj=method.invoke(target,args);
System.out.println("在调度真实对象之后的服务");
return obj;
}
public static void main(String[] args){
JdkProxyExample jdkProxyExample=new JdkProxyExample();
HelloWorld helloWorld=(HelloWorld)jdkProxyExample.bind(new HelloWorldImpl());
helloWorld.sayHelloWorld();
}
}public class Singleton {
public static Singleton instance = null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class){
if(instance==null){ //这一步要进行判断，是因为在多线程环境下，其他的线程也有可能进入第一个if中
instance=new Singleton();
}
}
}
return instance;
}
private Singleton() {
}
}单例模式最好的一种实现
public class Singleton{
public static Singleton instance=null;
public static Singleton getInstance(){
return SingletonFactory.getInstance();
}
private Singleton(){}
private static class SingletonFactory{
private static Singleton singleton=new Singleton();
public static Singleton getInstance(){
return singleton;
}
}
}观察者模式是一种发布订阅模式
- 被观察者需要继承 java.util.Observable类
- 观察者需要实现Observer接口
被观察者
public class ProductList extends Observable {
public static ProductList instance=null;
public static ProductList getInstance(){
if(instance==null){
synchronized (ProductList.class){
if(instance==null){
instance=new ProductList();
instance.productList=new ArrayList<String>();
}
}
}
return instance;
}
private ProductList(){}
private List<String> productList=null; //产品列表
/**
* 添加观察者
* @Param Observer 观察者
*/
public void addProductListObserver(Observer observer){
this.addObserver(observer);
}
/**
* 添加产品
* @param newProduct
*/
public void addProduct(String newProduct){
productList.add(newProduct);
System.out.println("产品列表新增了产品:"+newProduct);
this.setChanged();//设置被观察对象发生变化
this.notifyObservers(newProduct);//通知观察者，并传递新产品
}
}观察者
public class JingDongObserver implements Observer {
@Override
public void update(Observable o,Object product){
String newProduct=(String)product;
System.out.println("发布新产品["+newProduct+"]到京东电商接口");
}
}工厂模式：一个工厂可能生产不同型号的产品，那么每种产品都有一个类，用户在 工厂买该产品只要提供一个型号描述，就可以得到该工厂的指定型号的产品。
interface IProduct{
}
class Product1 implements IProduct{
public Product1(){
System.out.println("创建了1型号产品");
}
}
class Product2 implements IProduct{
public Product2(){
System.out.println("创建了2型号产品");
}
}
public class ProductFactory {
public static IProduct createProduct(String productNo){
switch (productNo){
case "1": return new Product1();
case "2": return new Product2();
default: return new Product1();
}
}
public static void main(String[] args){
IProduct product=ProductFactory.createProduct("1");
}
}