常见的设计模式:
工厂模式、单例模式、原型模式、代理模式、策略模式、委派模式、适配器模式、装饰器模式、观察者模式
SpringIOC:工厂模式、单例模式、装饰器模式
SpringAOP:代理模式,观察者模式
SpringMVC:委派模式,适配器模式
SpringJDBC:模版方法
1、工厂模式
1.1简单工厂模式:
适用于:创建的对象较少,客户端只关心传入工厂类的参数,对于如何创建对象的逻辑并不关心。
优点:只需要传入正确的参数,就可以获取所需的对象,对于创建的细节无需关心。
缺点:工厂类的职责过于重,当需要创建新的对象(产品),就需要修改工厂的判断逻辑,违背开闭原则;不易于扩展复杂的产品结构。
public interface Fruit {
void price();
}
@Data
public class Apple implements Fruit {
private String name;
private float weight;
private BigDecimal price;
public Apple() {
}
public Apple(String name) {
this.name = name;
}
@Override
public void price() {
}
}
public class FruitStore {
public Apple getFruit(String name) {
if (name.equals("apple")) {
return new Apple(name);
} else {
return null;
}
}
public Fruit createFruit(String className) {
try {
if (className != null && className.length() > 0) {
Class classforName = Class.forName(className);
System.out.println("classforName---" + classforName);
Object object = classforName.newInstance();
return (Apple)object;
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
public Fruit createFruit(Class className) {
try {
if (className != null) {
return (Apple)className.newInstance();
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
}
public class SimpleFactoryTest {
public static void main(String[] args) {
FruitStore fruitStore = new FruitStore();
Fruit fruit = fruitStore.getFruit("apple");
System.out.println(fruit.toString());
Fruit fruit1 = fruitStore.createFruit("com.tealala.pattern.factoryModel.simpleFactory.Apple");
System.out.println(fruit1.toString());
Fruit fruit2 = fruitStore.createFruit(Apple.class);
System.out.println(fruit2.toString());
}
}
测试结果为:
Apple(name=apple, weight=0.0, price=null)
classforName---class com.tealala.pattern.factory.Apple
Apple(name=null, weight=0.0, price=null)
Apple(name=null, weight=0.0, price=null)
1.2工厂方法模式(Factory Method Pattern)
适用场景:创建对象需要大量重复代码,客户端(应用层)不需要依赖产品实例如何创建,实现等细节。一个类通过子类来指定创建哪个类。
定义一个创建对象的接口,决定实例化哪个类由实现这个接口的子类来决定,具体来说就是:工厂接口的类实例化由子类来具体实现。【Define a interface for creating an Object,but let subclass decide which class to instantiate .The Factory lets a subclass defer instantiation it uses to subclass】
优点:只需要关心所需要产品对应的工厂,无需关心工厂具体实现的细节;加入新的产品符合开闭原则,提高的系统的可扩展性。
缺点:类的个数容易过多,增加代码结构的复杂度,增加系统的抽象性和理解难度。
@Data
public class Banana implements Fruit {
private String name;
public Banana() {
}
public Banana(String name) {
this.name = name;
}
@Override
public void price() {
}
}
public interface FruitStore {
Fruit init();
}
public class AppleStore implements FruitStore{
@Override
public Fruit init() {
return new Apple("apple");
}
}
public class BananaStore implements FruitStore {
@Override
public Fruit init() {
return new Banana("banana");
}
}
public class MethodFactoryTest {
public static void main(String[] args) {
FruitStore bananaStore = new BananaStore();
Fruit banana = bananaStore.init();
FruitStore appleStore = new AppleStore();
Fruit apple = appleStore.init();
System.out.println(banana.toString());
System.out.println(apple.toString());
}
}
运行结果:
Banana(name=banana)
Apple(name=apple, weight=0.0, price=null)
1.3抽象工厂模式(Abstract Factory Pattern):
提供一个创建一系列相关的或相互依赖对象的接口,无需指定它们的具体类【Provide an interface for creating families of related or dependent object without specifying their concrete classes】
属于创建型模型
适用场景:客户端(应用层)不依赖于产品类实例如何被创建,实现等细节;强调一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码;提供一个产品类的库,所有的产品以同一个接口出现,从而使客户端不依赖于具体的实现。
优点:产品在应用层隔离,无需关心创建细节;将一个系列的产品族统一到一起创建。
缺点:提前规定了所有可能被创建的产品集合,产品族中要扩展产品比较困难,需要修改抽象工厂的接口;增加了系统的抽象性和理解难度。
public interface Fruit {
String getName();
}
public interface IApple extends Fruit{
}
public interface IBanana extends Fruit {
}
public class CDApple implements IApple {
@Override
public String getName() {
return "cdApple";
}
}
public class CQApple implements IApple {
@Override
public String getName() {
return "cqApple";
}
}
public class CDBanana implements IBanana{
@Override
public String getName() {
return "cdBanana";
}
}
public class CQBanana implements IBanana {
@Override
public String getName() {
return "cqBanana";
}
}
public interface FruitStoreFactory {
IApple initApple();
IBanana initBanana();
}
public class CDStoreFactory implements FruitStoreFactory {
@Override
public IApple initApple() {
return new CDApple();
}
@Override
public IBanana initBanana() {
return new CDBanana();
}
}
public class CQStoreFactory implements FruitStoreFactory {
@Override
public IApple initApple() {
return new CQApple();
}
@Override
public IBanana initBanana() {
return new CQBanana();
}
}
public class AbstracFactoryTest {
public static void main(String[] args) {
FruitStoreFactory fruitStoreFactory1 = new CDStoreFactory();
IApple apple1 = fruitStoreFactory1.initApple();
IBanana banana1 = fruitStoreFactory1.initBanana();
System.out.println(apple1.getName());
System.out.println(banana1.getName());
FruitStoreFactory fruitStoreFactory2 = new CQStoreFactory();
IApple apple2 = fruitStoreFactory2.initApple();
IBanana banana2 = fruitStoreFactory2.initBanana();
System.out.println(apple2.getName());
System.out.println(banana2.getName());
}
}
执行结果为:
cdApple
cdBanana
cqApple
cqBanana