Sping系列課程–工廠

第一章 引言

4. 工廠設計模式

4.1 什么是工廠設計模式

1. 概念：通過工廠類，創建對象User user = new User();UserDAO userDAO = new UserDAOImpl();2. 好處： 解耦合耦合：指的是代碼間的強關聯關系，一方的改變會影響到另一方問題：不利于代碼維護UserService userService = new UserServiceImpl();

4.2 簡單的工廠實現

package com.jujuxiaer.basic;import java.io.IOException; import java.io.InputStream; import java.util.Properties;/** * @author Jujuxiaer * @date 2020-11-06 20:34 */ public class BeanFactory {private static Properties env = new Properties();/* 將applicationContext.properties文件中的內容讀取到Properties集合中，然后這個IO操作屬于系統級資源，避免重復性的打開IO，最后在程序啟動的時候一次性的讀取想要的內容所以讀這個配置文件時候，可以在靜態代碼塊中進行*/static {// 1. 獲得IO輸入流InputStream inputStream = BeanFactory.class.getResourceAsStream("/applicationContext.properties");// 2. 文件內容封裝到Properties集合中try {env.load(inputStream);} catch (IOException e) {e.printStackTrace();}}/*對象創建的三種方式：1. 直接調用構造方法 創建對象 UserService userService = new UserServiceImpl();2. 通過反射的方式 創建對象 解耦合Class clazz = Class.forName("com.jujuxiaer.basic.UserServiceImpl");UserService userService = (UserService) clazz.newInstance();*/public static UserService getUserService() {// 使用new 的方式創建對象// return new UserServiceImpl();// 使用反射方式創建對象UserService userService = null;try {// 但是在這里類的全限定類名字符串還是存在耦合，可通過配置文件的方式解決// Class clazz = Class.forName("com.jujuxiaer.basic.UserServiceImpl");Class clazz = Class.forName(env.getProperty("userService"));userService = (UserService) clazz.newInstance();} catch (ClassNotFoundException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}return userService;}public static UserDAO getUserDAO() {UserDAO userDAO = null;try {Class clazz = Class.forName(env.getProperty("userDAO"));userDAO = (UserDAO) clazz.newInstance();} catch (ClassNotFoundException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}return userDAO;} }

4.3 通用工廠設計

• 問題

  簡單工廠會存在大量的代碼冗余

• 通用工廠的代碼

// 創建一切想要的對象 public class BeanFactory {/*** @param key 配置文件中的key，比如 userService userDAO* @return*/public static Object getBean(String key){Object ret = null;try{Class<?> clazz = Class.forName(env.getProperty(key));ret = clazz.newInstance();} catch (Exception e){}return ret;} }

4.4 通用工廠的使用方式

1. 定義類型（類） 2. 通過配置文件的配置來告知工廠（applicationContext.properties）key = value 3. 通過工廠獲得類的對象Object ret = BeanFactory.getBean("key");

5. 總結

Spring本質： 工廠ApplicationContext(applicationContext.xml)

第二章 第一個Spring程序

1. 軟件版本

1. JDK1.8+ 2. Maven3.5 3. IDEA2020.2 4. SpringFramework 5.1.4官方網址 www.spring.io

2. 環境搭建

• Spring的Jar包

  # 設置pom依賴 <dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.1.4.RELEASE</version> </dependency>

• Spring的配置文件

  1. 配置文件的放置位置： 任意位置，沒有硬性要求 2. 配置文件的命名：沒有硬性要求，建議我們叫applicationContext.xml思考：日后應用Spring框架時，需要進行配置文件路徑的設置

3. Spring的核心API

• ApplicationContext

  作用： Spring提供的ApplicationContext這個工廠，用于地對象的創建 好處：解耦合

  • ApplicationContext接口類型

    接口：屏蔽實現的差異 非Web環境：ClassPathXmlApplicationContext(常用于Main函數或Junit單元測試中) Web環境：XmlWebApplicationContext

  • 重量級資源

    ApplicationContext工廠的對象會占用大量的內存。 不會頻繁的創建對象：一個應用只會創建一個工廠對象。 ApplicationContext工廠：一定是線程安全的（也就是能被多線程并發訪問）

4. 程序開發

1. 創建類型（類） 2. 配置文件的配置 applicationContext.xml<!-- id屬性： 名字（唯一）class屬性：配置全限定類名--><bean id="person" class="com.jujuxiaer.basic.Person"/> 3. 通過工廠類，獲取對象ApplicationContext|- ClassPathXmlApplicationContext// 1. 獲取Spring工廠ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");// 2. 通過工廠獲取對象Person person = (Person) ctx.getBean("person");

5. 細節分析

• 名詞解釋

  Spring工廠創建的對象，叫做Bean或者組件（Component）

• Spring工廠中的相關方法

  // 1. 獲取Spring工廠 ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml"); // 2. 通過工廠獲取對象 Person person = (Person) ctx.getBean("person");// 不需要進行強轉 Person person = ctx.getBean("person", Person.class);// 此時在Spring工廠的配置當中，只能有一個Bean標簽是Person類型, 不然的話會拋異常 // 拋的異常信息： expected single matching bean but found 2: person,person1 Person person = ctx.getBean(Person.class);// 返回的是 Bean標簽中定義的bean的名字 數組 // ctx.getBeanDefinitionNames() 獲取的是Spring工廠配置文件中所有Bean標簽的id值 String[] beanDefinitionNames = ctx.getBeanDefinitionNames(); for (String beanDefinitionName : beanDefinitionNames) {System.out.println("beanDefinitionName = " + beanDefinitionName); } System.out.println("person = " + person);// 根據類型獲取Spring工廠配置文件中對應的Bean標簽中id的值 String[] beanNamesForType = ctx.getBeanNamesForType(Person.class); for (String beanName : beanNamesForType) {System.out.println("beanName = " + beanName); }// 用于判斷會否存在指定的id值的Bean if (ctx.containsBeanDefinition("11person")) {System.out.println("True = " + true); } else {System.out.println("False = " + false); }// 用于判斷會否存在指定的id值的Bean, 暫時來看和上面的ctx.containsBeanDefinition("person")作用一樣 if (ctx.containsBean("person")) {System.out.println("True = " + true); } else {System.out.println("False = " + false); }

• 配置文件中需要注意的細節

  1. 只配置class屬性 <bean class="com.jujuxiaer.basic.Person"/>a) 上述這種配置，有沒有id值呢，也就是Spring會為我們賦上id值嗎回答： 有id值，值為 com.jujuxiaer.basic.Person#0b) 上述這種配置方式，應用功能場景：如果這個bean只需使用一次，那么就可以省略id值如果這個bean會使用多次或者被其他bean引用，則需要設置id值2. name屬性 作用： 用于在Spring配置文件中，為bean對象定義別名 相同：1. ctx.getBean("id|name"); --> Object2. <bean id="" class=""/> 等效<bean name="" class=""/> 區別：1. 別名可以定義多個，但是id屬性只能有一個值<bean id="person" name="p,p1" class="com.jujuxiaer.basic.Person"/> 多個別名之間以逗號分隔2. XML的id屬性的值，命名要求： 必須要以字母開頭，后面可跟字母、數字、下劃線、連字符，不能以特殊字符開頭，比如"/person"name屬性的值，命名沒有要求，比如可以設置成"/person"name屬性會應用在特殊命名的場景中： /person (spring+struct1)XML發展到了今天：id屬性的限制，不存在了， 比如亦可以用"/person"命名3. 代碼// 用于判斷會否存在指定的id值的Bean，不能判斷name屬性值if (ctx.containsBeanDefinition("p")) {System.out.println("True = " + true);} else {System.out.println("False = " + false);}// 用于判斷會否存在指定的id值的Bean, 暫時來看和上面的ctx.containsBeanDefinition("person")作用一樣// 也可以判斷name屬性值if (ctx.containsBean("p")) {System.out.println("True = " + true);} else {System.out.println("False = " + false);}

6. Spring工廠底層實現原理（簡易版）

? 注意：Spring工廠是可以調用對象私有構造函數創建對象的

7. 思考

問題： 在未來的開發過程中，是不是所有的對象都交由Spring工廠來創建呢？ 回答： 理論來說，是的。但是又特例：對于實體對象（entity）不會交給Spring創建，而是交由持久層創建。

第三章 Spring5.x與日志框架的整合

Spring與日志框架整合后，日志框架就能在控制臺中，輸出Spring框架運行過程中的一些重要的信息。 好處：便于了解Spring框架的運行過程，利于程序的調試。

• Spring 如何整合日志框架

  默認Spring1.2.3都是與commons-logging.jar整合Spring5.x默認整合的日志框架為logback log4j2Spring5.x整合log4j1. 引入log4j jar包2. 引入log4j.properties配置文件

  • pom

    <dependency><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId><version>1.7.25</version><scope>test</scope> </dependency><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version> </dependency>

  • log4j.properties

    # resources文件夾根目錄下 ### 配置根 log4j.rootLogger = debug,console### 日志輸出到控制臺顯示 log4j.appender.console = org.apache.log4j.ConsoleAppender log4j.appender.console.Target = System.out log4j.appender.console.layout = org.apache.log4j.PatternLayout log4j.appender.console.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

第四章 注入（injection）

1. 什么是注入

通過Spring的工廠以及配置文件，為所創建對象的成員變量賦值

1.1 為什么需要注入

通過編碼的方式為成員變量賦值，存在耦合

1.2 如何進行注入，開發步驟

• 類為成員變量提供get/set方法

• 配置Spring的配置文件

  <bean id="person" class="com.jujuxiaer.basic.Person"><property name="id"><value>10</value></property><property name="name"><value>juzhihua</value></property> </bean>

1.3 注入的好處

解耦合

2. Spring注入的原理分析（簡易版）

Spring底層通過調用對象屬性對應的set方法，完成成員變量的賦值，這種方式我們稱為set注入

第五章 set注入詳解

針對不同類型的成員變量，在<property>標簽中需要嵌入其他標簽

1. JDK內置類型

1.1 String + 8中基本類型

<value>jujuxiaer</value>

1.2 數組

<property name="emails"><list><value>11@qq.com</value><value>22@qq.com</value></list> </property>

1.3 set集合

對應的成員變量為Set tels; 因為Set的泛型此時是String，所有標簽中嵌套的為標簽，如果Set泛型為其他的類型，則標簽中嵌套的為其他標簽

<property name="tels"><set><value>1341111111</value><value>1342222222</value></set> </property>

1.4 list集合

<property name="addresses"><list><value>湖北省武漢市</value><value>上海市黃浦區</value></list> </property><list><ref bean<set </list>

1.5 map集合

注意： map -- entry -- 鍵有特定的標簽 <key></key>值根據對應的類型選擇對應類型的標簽，比如<ref bean <set <list 等等 <property name="qqs"><map><entry><key><value>jujuxiaer</value></key><value>1225449109</value></entry></map> </property>

1.6 Properties

Properties類型：特殊的Map，該map的鍵為String，值也為String <property name="p"><props><prop key="key1">value1</prop><prop key="key2">value2</prop></props> </property>

1.7 復雜JDK類型（Date）

需要程序員自定義類型轉換器，處理。

2. 用戶自定義類型

2.1 第一種方式

• 為成員變量提供get/set方法

• 配置文件中進行注入（賦值）

  <bean id="userService" class="com.jujuxiaer.basic.UserServiceImpl"><property name="userDAO"><bean class="com.jujuxiaer.basic.UserDAOImpl"/></property> </bean>

2.2 第二種方式

• 第一種方式存在的問題

  1. 配置文件代碼冗余 2. 被注入的對象（userDAO），多次創建，浪費（JVM）內存資源

• 為成員變量提供get/set方法

• 配置文件中進行注入（賦值）

  <bean id="userDAO" class="com.jujuxiaer.basic.UserDAOImpl"/> <bean id="userService" class="com.jujuxiaer.basic.UserServiceImpl"><property name="userDAO"><ref bean="userDAO"/></property> </bean># Spring4.x 廢棄了 <ref local=""/> 基本等效 <ref bean=""/>

3. set注入的簡化方式

3.1 基于屬性簡化

# JDK類型注入 <property name="name"><value>jujuxiaer</value> </property><property name="name" value="jujuxiaer"/># 注意：value屬性，只能簡化8種基本類型+String 注入標簽# 用戶自定義類型 <bean id="userDAO" class="com.jujuxiaer.basic.UserDAOImpl"/> <bean id="userService" class="com.jujuxiaer.basic.UserServiceImpl"><property name="userDAO"><ref bean="userDAO"/></property> </bean># 用戶自定義類型，簡化后 <bean id="userDAO" class="com.jujuxiaer.basic.UserDAOImpl"/> <bean id="userService" class="com.jujuxiaer.basic.UserServiceImpl"><property name="userDAO" ref="userDAO"/> </bean>

3.2 基于p命名空間簡化

# JDK類型注入 <bean id="person" class="com.jujuxiaer.basic.Person"><property name="name"><value>jujuxiaer</value></property> </bean><bean id="person" class="com.jujuxiaer.basic.Person" p:name="jujuxiaer"/># 注意：value屬性，只能簡化8種基本類型+String 注入標簽# 用戶自定義類型 <bean id="userDAO" class="com.jujuxiaer.basic.UserDAOImpl"/> <bean id="userService" class="com.jujuxiaer.basic.UserServiceImpl"><property name="userDAO"><ref bean="userDAO"/></property> </bean># 用戶自定義類型，簡化后 <bean id="userDAO" class="com.jujuxiaer.basic.UserDAOImpl"/> <bean id="userService" class="com.jujuxiaer.basic.UserServiceImpl" p:userDAO-ref="userDAO"/>

第六章 構造注入

注入：通過Spring的配置文件，為成員變量賦值 set注入： Spring通過調用set方法，通過配置文件為成員變量賦值 構造注入： Spring通過調用構造方法，通過配置文件為成員變量賦值

1. 開發步驟

• 提供有參的構造方法

  public class Customer implements Serializable {private String name;private int age;public Customer(String name, int age) {this.name = name;this.age = age;} }

• Spring的配置文件

  <bean id="customer" class="com.jujuxiaer.basic.constructer.Customer"><constructor-arg><value>jujuxiaer</value></constructor-arg><constructor-arg><value>102</value></constructor-arg> </bean>

2. 構造方法重載

2.1 參數個數不同時

通過控制<constructor-arg>標簽數量進行區分

2.2 參數個數相同時

通過在標簽引入type屬性來進行類型的區分<constructor-arg type=""><bean id="customer" class="com.jujuxiaer.basic.constructer.Customer"><constructor-arg type="int"><value>23</value></constructor-arg> </bean>

3. 注入總結

未來實戰中使用set注入，還是構造注入？ 回答：set注入會更多原因：1. 構造注入麻煩，有重載2. Spring框架底層，大量應用了set注入

第七章 反轉控制 與 依賴注入

1. 反轉（轉移）控制（Inverse of Control，簡稱IOC）

控制： 對于成員變量的賦值的控制權 反轉控制：把對于成員變量賦值的控制權，從代碼中反轉（轉移）到了Spring工廠和配置文件中完成好處： 解耦合 底層實現：工廠設計模式

2. 依賴注入（Dependency Injection，簡稱DI）

注入：通過Spring工廠和配置文件，為對象（bean/組件）的成員變量賦值依賴注入：一個類需要另一個類時，就意味著依賴，一旦出現依賴，就可以把另一個類作為本類的成員變量，最終通過Spring配置文件進行注入（賦值）。

第八章 Spring工廠創建復雜對象

1. 什么是復雜對象

復雜對象：指的是不能直接通過new構造方法創建的對象ConnectionSqlSessionFactory

2. Spring工廠創建復雜對象的3中方式

2.1 FactoryBean接口

• 開發步驟

  • 實現FactoryBean接口

• Spring配置文件的配置

  # 如果Class屬性中指定的類型是FactoryBean接口的實現類，那么通過id值獲得的是這個類所創建的復雜對象，比如Connection <bean id="conn" class="com.jujuxiaer.factorybean.ConnectionFactoryBean"/>

• 細節

  • 如果 ，ctx.getBean("&conn"); 獲得的就是ConnectionFactoryBean對象

  • isSingleton方法

    返回true，只會創建一個復雜對象

    返回false，每一次都會創建新的對象

    問題：根據這個對象的特點，決定是返回true（SqlSessionFactory），還是false（Connection）

  • mysql高版本在連接創建時，需要指定SSL證書，解決問題的方式

    url = "jdbc:mysql://localhost:3306/suns?useSSL=false"

  • 依賴注入的體會（DI）

    把ConnectionFactoryBean中依賴的四個字符串信息，進行配置文件的注入 好處：解耦合 <bean id="conn" class="com.jujuxiaer.factorybean.ConnectionFactoryBean"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/suns?useSSL=false"/><property name="user" value="root"/><property name="password" value="123456"/> </bean>

• FactoryBean的實現原理（簡易版）

  接口回調 1. 為什么Spring規定FactoryBean接口 實現 并且getObject()? 2. ctx.getBean("conn");獲得的是復雜對象Connection，而不是獲得ConnectionFactoryBeanSpring內部運行流程： 1. 通過conn獲得ConnectionFactoryBean類對象，進而通過instanceod判斷出是FactoryBean接口的實現類 2. Spring按照規定getObejct() --> Connection 3. 返回Connection

• Factory總結

  Spring中用于創建復雜對象的一種方式，也是Spring原生提供的，后續我們在講解Spring整合其他框架時，會大量應用FactoryBean

2.2 實例工廠

1. 避免Spring框架的侵入 2. 整合遺留系統

• 開發步驟

  <bean id="connFactory" class="com.jujuxiaer.factorybean.ConnectionFactory"/> <bean id="conn" factory-bean="connFactory" factory-method="getConnection"/>

2.3 靜態工廠

• 開發步驟

  <bean id="conn" class="com.jujuxiaer.factorybean.StaticConnectionFactory" factory-method="getConnection"/>

3. Spring工廠創建對象總結

第九章 控制Spring工廠創建對象次數

1. 如何控制簡單對象的創建次數

<bean id="account" class="com.jujuxiaer.scope.Account" scope="singleton|prototype"/> singleton: 只會創建一次簡單對象 prototype: 每一次都會創建簡單對象默認為singleton

2. 如何控制復雜對象的創建次數

FactoryBean {isSingleton() {return true 只會創建一次return false 每一次都會創建新的} } 如果沒有isSingleton方法，還是通過制定scope屬性，進行對象創建次數的控制。

3. 為什么要控制對象的創建次數

好處：節省不必要的內存浪費

• 什么樣的對象只創建一次

  1. SqlSessionFactoryBean 2. DAO 3. Service

• 什么樣的對象，每一次都要創建新的呢？

  1. Connection(因為要控制事務，不能被大家共用) 2. SqlSession(里面封裝了Connection) | Session 3. Struct2 Action

第十章 對象的生命周期

1. 什么是對象的生命周期

指的是一個對象創建、存活、消亡的一個完整過程。

2. 為什么要學習對象的生命周期

由Spring來負責對象的創建、存活、銷毀，了解生命周期后，有利于我們使用好Spring為我們創建的對象。

3. 生命周期的3個階段

• 創建階段

  Spring工廠何時創建

  • scope=“singleton”

    Spring工廠創建的同時，對象創建注意： 設置scope="singleton" 這種情況下，也需要在獲取對象的同時，創建對象 <bean id="product" class="com.jujuxiaer.life.Product" scope="singleton" lazy-init="true"/>

  • scope=“prototype”

    Spring工廠會在獲取對象的同時，創建對象 ctx.getBean("")

• 初始化階段

  Spring工廠在創建完成對象后，調用對象的初始化方法，完成對應的初始化操作1. 初始化方法提供：程序員根據需求，提供初始化方法，最終完成初始化操作 2. 初始化方法調用：Spring工廠進行調用

  • InitializingBean接口

    public class Product implements InitializingBean {public Product() {System.out.println("Product.Product");}/*** 完成對象的初始化操作* @throws Exception*/public void afterPropertiesSet() throws Exception {System.out.println("Product.afterPropertiesSet");} }

  • 對象中提供一個普通的方法

    public void myInit() {}// <bean id="product" class="xxx.Product" init-method="myInit"/>

  • 細節分析

  • 如果一個對象既實現了InitializingBean，又提供了普通的初始化方法，執行順序是怎樣呢？

    1. InitializingBean 2. 普通的初始化方法

  • 注入一定發生在初始化操作的前面

  • 什么叫做初始化操作

    資源的初始化：數據庫 IO 網絡 ......

• 銷毀階段

  Spring銷毀對象前，會調用對象的銷毀方法，完成銷毀操作1. Spring什么時候銷毀所創建的對象？ctx.close(); 2. 銷毀方法：程序員根據自己的需求，定義銷毀方法，完成銷毀操作調用：Spring工廠完成調用
  • DisposableBean
  • 定義一個普通的銷毀方法
  public class Product implements InitializingBean, DisposableBean {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;System.out.println("Product.setName");}public Product() {System.out.println("Product.Product");}// 完成對象的初始化操作public void afterPropertiesSet() throws Exception {System.out.println("Product.afterPropertiesSet");}public void myInit() {System.out.println("Product.myInit");}public void destroy() throws Exception {System.out.println("Product.destroy");}public void myDestroy() throws Exception {System.out.println("Product.myDestroy");} }<bean id="product" class="com.jujuxiaer.life.Product" init-method="myInit" destroy-method="myDestroy"><property name="name" value="productName"/> </bean>@Test public void test17() {// 1. 獲取Spring工廠ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");ctx.close(); }
  • 細節分析

• 銷毀方法的操作只適用于scope=“singleton”

• 什么叫做銷毀操作

  主要指的是 資源的釋放操作，比如 io.close(); connection.close();

第十一章 配置文件參數化

把Spring配置文件中需要經常修改的字符串信息，轉移到一個更小的配置文件中1. Spring的配置文件中存在經常修改的字符串？存在，以數據庫連接相關的參數 代表 2. 經常變化字符串，在Spring配置文件中，直接修改不利于項目維護（修改） 3. 轉移到一個小的配置文件（.properties） 利于維護（修改）配置文件參數化：利于Spring配置文件的維護（修改）

1. 配置文件參數化的開發步驟

• 提供一個小的配置文件（.properties）

  # 文件名稱：隨意；放置位置：隨意 jdbc.driverClassName = com.mysql.jdbc.Driver jdbc.url =jdbc:mysql://localhost:3306/suns?useSSL=false jdbc.user = root jdbc.password = 123456

• Spring的配置文件和小配置文件的整合

  <!-- 在applicationContext.xml中加入以下配置 --> <context:property-placeholder location="classpath:/db.properties"/>

• 在Spring配置文件中通過${key}獲取小配置文件中對應的值

第十二章 自定義類型轉換器

1. 類型轉換器

作用：Spring通過類型轉換器把配置文件中字符串類型的數據，轉換成了對象中成員變量對應類型的數據，進而完成了注入

2. 自定義類型轉換器

需要自定義類型轉換器的原因： 當Spring內部沒有提供特定類型轉換器時，而程序員在應用的過程中還需要使用個，那么就需要程序員自己定義類型轉換器

• 類實現Convert接口

  /*** @author Jujuxiaer* @date 2020-11-08 14:25* Converter<String, Date>中String是待轉換的原始數據類型，Date是轉換后的數據類型*/ public class MyDateConverter implements Converter<String, Date> {/*convert作用： String --> Dateparam: source 代表的是配置文件中 日期字符串 <value>2020-11-07</value>return: 當把轉換好的Date作為convert方法返回值后，Spring自動為birthday屬性進行注入（賦值）*/@Overridepublic Date convert(String s) {SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");Date date = null;try {date = sdf.parse(s);} catch (ParseException e) {e.printStackTrace();}return date;} }

• 在Spring的配置文件中進行配置

  • MyDateConverter對象創建出來

    <!--Spring創建MyDateConverter類型對象--><bean id="myDateConverter" class="com.jujuxiaer.converter.MyDateConverter"/>

  • 類型轉換器的注冊

    <!--用于注冊類型轉換器 id必須為conversionService--> <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean"><property name="converters"><set><ref bean="myDateConverter"/></set></property> </bean>

3. 細節

• MyDateConverter中的日期格式，通過依賴注入的方式，由配置文件完成賦值。

  public class MyDateConverter implements Converter<String, Date> {private String pattern;public String getPattern() {return pattern;}public void setPattern(String pattern) {this.pattern = pattern;}/*convert作用： String --> Dateparam: source 代表的是配置文件中 日期字符串 <value>2020-11-07</value>return: 當把轉換好的Date作為convert方法返回值后，Spring自動為birthday屬性進行注入（賦值）*/@Overridepublic Date convert(String s) {SimpleDateFormat sdf = new SimpleDateFormat(pattern);Date date = null;try {date = sdf.parse(s);} catch (ParseException e) {e.printStackTrace();}return date;} } <!--Spring創建MyDateConverter類型對象--> <bean id="myDateConverter" class="com.jujuxiaer.converter.MyDateConverter"><property name="pattern" value="yyyy-MM-dd"/> </bean>

• ConversionServiceFactoryBean定義id屬性，必須為conversionService

• Spring框架內置了日期類型轉換器

  內置的日期類型轉換器支持的日期格式：2010/11/08而不支持，比如2020-11-08 日期格式

第十三章 后置處理Bean

BeanPostProcessor作用：對Spring工廠所創建的對象，進行再加工AOP底層實現：注意： BeanPostProcesser接口xxx (){}

• 后置處理Bean de 運行原理分析

程序員源實現BeanPostProcesser規定接口中的方法： Object postProcessBeforeInitialization(Object bean, String beanName) 作用：Spring創建完對象，并進行注入后，可以運行Before方法進行加工 獲得創建好的對象：通過方法的參數 最終通過返回值交給Spring框架Object postProcessAfterInitialization(Object bean, String beanName) 作用：Spring執行完對象的初始化操作后，可以運行After方法進行加工 獲得創建好的對象：通過方法的參數 最終通過返回值交給Spring框架實戰中： 很少處理Spring的初始化操作（InitializingBean），沒有必要區分Before After。只需要實現其中一個After方法即可。但注意postProcessBeforeInitialization方法也需要將bean對象返回。

• BeanPostProcesser開發步驟

• 類 實現BeanPostProcesser接口

  public class MyBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {Category category = (Category) bean;category.setName("xiaowangba");return bean;} }

• Spring的配置文件進行配置

  <bean id="myBeanPostProcessor" class="com.jujuxiaer.beanpost.MyBeanPostProcessor"/>

• BeanPostProcessor細節

  BeanPostProcessor會對Spring工廠中所有創建的對象進行加工

總結

以上是生活随笔為你收集整理的Sping系列课程--工厂的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。