在使用Spring框架的過程中，其實就是為了使用IOC/DI和AOP，面向切面編程，這兩個是Spring的靈魂。
主要用到的設計模式有工廠模式和代理模式。
IOC就是典型的工廠模式，通過sessionfactory去注入實例。
AOP就是典型的代理模式的體現。
1.工廠模式
工廠模式可以分為三類：
1）簡單工廠模式（Simple Factory）
一個抽象類，子類繼承，工廠類根據條件返回。
public abstract class INoodles { /** * 描述每種面條啥樣的 */ public abstract void desc(); } public class LzNoodles extends INoodles { @Override public void desc() { System.out.println("蘭州拉面 上海的好貴 家里才5 6塊錢一碗"); } } public class PaoNoodles extends INoodles { @Override public void desc() { System.out.println("泡面好吃 可不要貪杯"); } } public class GankouNoodles extends INoodles { @Override public void desc() { System.out.println("還是家里的干扣面好吃 6塊一碗"); } } public class SimpleNoodlesFactory { public static final int TYPE_LZ = 1;//蘭州拉面 public static final int TYPE_PM = 2;//泡面 public static final int TYPE_GK = 3;//干扣面 //方法通常是靜態的，所以也稱之為靜態工廠 public static INoodles createNoodles(int type) { switch (type) { case TYPE_LZ: return new LzNoodles(); case TYPE_PM: return new PaoNoodles(); case TYPE_GK: default: return new GankouNoodles(); } } }
/** 簡單工廠模式 */
INoodles noodles = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_GK); noodles.desc();
擴展性差（我想增加一種面條，除了新增一個面條產品類，還需要修改工廠類方法），不同的產品需要不同額外參數的時候 不支持。
2）工廠方法模式（Factory Method）
工廠方法模式去掉了簡單工廠模式中工廠方法的靜態屬性，使得它可以被子類繼承。這樣在簡單工廠模式里集中在工廠方法上的壓力可以由工廠方法模式里不同的工廠子類來分擔。
產品類：
abstract class BMW { public BMW(){ } } public class BMW320 extends BMW { public BMW320() { System.out.println("制造-->BMW320"); } } public class BMW523 extends BMW{ public BMW523(){ System.out.println("制造-->BMW523"); } }
創建工廠類：
interface FactoryBMW { BMW createBMW(); } public class FactoryBMW320 implements FactoryBMW{ @Override public BMW320 createBMW() { return new BMW320(); } } public class FactoryBMW523 implements FactoryBMW { @Override public BMW523 createBMW() { return new BMW523(); } }
客戶類：
public class Customer { public static void main(String[] args) { FactoryBMW320 factoryBMW320 = new FactoryBMW320(); BMW320 bmw320 = factoryBMW320.createBMW(); FactoryBMW523 factoryBMW523 = new FactoryBMW523(); BMW523 bmw523 = factoryBMW523.createBMW(); } }
3）抽象工廠模式（Abstract Factory）
為創建一組相關或相互依賴的對象提供一個接口，而且無需指定他們的具體類。
抽象工廠：
public abstract class AbstractFactory { public abstract Flyable createFlyable(); public abstract Moveable createMoveable(); public abstract Writeable createWriteable(); }
具體工廠：
public class Factory1 extends AbstractFactory { @Override public Flyable createFlyable() { return new Aircraft(); } @Override public Moveable createMoveable() { return new Car(); } @Override public Writeable createWriteable() { return new Pen(); } }
抽象產品接口：
public interface Flyable { public void fly(int height); }
具體產品：
public class Aircraft implements Flyable { @Override public void fly(int height) { System.out.println("我是一架客運機，我目前的飛行高度為：" + height + "千米。"); } }
測試
public class FactoryTest { public static void main(String[] args) { AbstractFactory factory = new Factory1(); Flyable flyable = factory.createFlyable(); flyable.fly(1589); Moveable moveable = factory.createMoveable(); moveable.run(87.6); Writeable writeable = factory.createWriteable(); writeable.write("Hello World."); } }
2.代理模式
1)靜態代理
靜態代理在使用時,需要定義接口或者父類,被代理對象與代理對象一起實現相同的接口或者是繼承相同父類。
模擬保存動作,定義一個保存動作的接口:IUserDao.java,然后目標對象實現這個接口的方法UserDao.java,此時如果使用靜態代理方式,就需要在代理對象(UserDaoProxy.java)中也實現IUserDao接口.調用的時候通過調用代理對象的方法來調用目標對象.
需要注意的是,代理對象與目標對象要實現相同的接口,然后通過調用相同的方法來調用目標對象的方法
/** * 接口 */ public interface IUserDao { void save(); } /** * 接口實現 * 目標對象 */ public class UserDao implements IUserDao { public void save() { System.out.println("----已經保存數據!----"); } } /** * 代理對象,靜態代理 */ public class UserDaoProxy implements IUserDao{ //接收保存目標對象 private IUserDao target; public UserDaoProxy(IUserDao target){ this.target=target; } public void save() { System.out.println("開始事務..."); target.save();//執行目標對象的方法 System.out.println("提交事務..."); } } /** * 測試類 */ public class App { public static void main(String[] args) { //目標對象 UserDao target = new UserDao(); //代理對象,把目標對象傳給代理對象,建立代理關系 UserDaoProxy proxy = new UserDaoProxy(target); proxy.save();//執行的是代理的方法 } }
可以做到在不修改目標對象的功能前提下,對目標功能擴展.
缺點:因為代理對象需要與目標對象實現一樣的接口,所以會有很多代理類,類太多.同時,一旦接口增加方法,目標對象與代理對象都要維護.
2)動態代理
特點：
- 代理對象,不需要實現接口
- 代理對象的生成,是利用JDK的API,動態的在內存中構建代理對象(需要我們指定創建代理對象/目標對象實現的接口的類型)
- 動態代理也叫做:JDK代理,接口代理
JDK實現代理只需要使用newProxyInstance方法,但是該方法需要接收三個參數,完整的寫法是:
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )
注意該方法是在Proxy類中是靜態方法,且接收的三個參數依次為:
ClassLoader loader,:指定當前目標對象使用類加載器,獲取加載器的方法是固定的Class<?>[] interfaces,:目標對象實現的接口的類型,使用泛型方式確認類型InvocationHandler h:事件處理,執行目標對象的方法時,會觸發事件處理器的方法,會把當前執行目標對象的方法作為參數傳入
/** * 創建動態代理對象 * 動態代理不需要實現接口,但是需要指定接口類型 */ public class ProxyFactory{ //維護一個目標對象 private Object target; public ProxyFactory(Object target){ this.target=target; } //給目標對象生成代理對象 public Object getProxyInstance(){ return Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("開始事務2"); //執行目標對象方法 Object returnValue = method.invoke(target, args); System.out.println("提交事務2"); return returnValue; } } ); } }
/** * 測試類 */ public class App { public static void main(String[] args) { // 目標對象 IUserDao target = new UserDao(); // 【原始的類型 class cn.itcast.b_dynamic.UserDao】 System.out.println(target.getClass()); // 給目標對象，創建代理對象 IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance(); // class $Proxy0 內存中動態生成的代理對象 System.out.println(proxy.getClass()); // 執行方法 【代理對象】 proxy.save(); } }
2.代理對象的生成,是利用JDK的API,動態的在內存中構建代理對象(需要我們指定創建代理對象/目標對象實現的接口的類型)
3.動態代理也叫做:JDK代理,接口代理
參考鏈接：
http://blog.csdn.net/zxt0601/article/details/52798423
http://blog.csdn.net/lemon_tree12138/article/details/46225213
https://www.cnblogs.com/cenyu/p/6289209.html