Spring -工厂

1、引言

EJB存在问题

EJB: Enterprise Java Beans 企业级Java bean

早些年基本用它，但存在两个问题：

运行环境苛刻：需要运行在EJB容器 Weblogic、Webhphere (收费)支持，但是Tomcat没有EJB容器。
代码移植性差：运行在那个容器就需要实现相应容器的接口，不支持后续换环境运行

综上大家就对EJB下了一个非常重要的定义：EJB是一个重量级的框架

什么是Spring？

spring是一个轻量级的JavaEE解决方案，整合众多的设计模式。

轻量级

1 对运行环境没有额外要求
2 代码移植性高，不需要实现什么接口

JavaEE解决放案

解决分层开发的每一层的问题
  springMVC ：controller层
  AOP ：service层事务控制和日志处理功能
  与Mybatis整合 ：DAO层
故spring是一个完整的体系的解决方案

整合设计模式
```
工厂、代理、模板、策略...
```

设计模式又是什么？

1 广义：⾯向对象设计中，解决特定问题的经典代码
2 狭义：GOF四人帮定义的23中设计模式

Spring工厂

好处：解耦合

耦合：指定是代码间的强关联关系，一方的改变会影响到另一方

问题：不利于代码维护

把接口的实现类，硬编码在程序中 UserService userService = new UserServiceImpl();

创建BeanFactory类解耦（耦合转移）

package com.jie;

public class BeanFactory {
    public static UserService getUserService() {
        //创建对象的两种方式：1.new  2.反射 Class clazz = class.forName("");
        //clazz.newInstance();
        UserService userService =  null;
        try {
            Class<?> clazz = Class.forName("com.jie.UserServiceImpl");
            userService = (UserService) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return userService;
    }
}

@Test
public void test() {

    //UserService userService = new UserServiceImpl();
    
    UserService userService = BeanFactory.getUserService(); //解耦

    userService.login("jwww","123456");
}

如此一来确实是解耦了，但是耦合跑这里来了，并没有消失，那不是解了个寂寞么

Class<?> clazz = Class.forName("com.jie.UserServiceImpl");

所以我们想着把它抽取出来，放到我们properties配置文件中即可

新建配置文件applicationContext.properties

userService = com.jie.UserServiceImpl

tips : properties是特殊的map，key为String、value为String value = Properties.getPropertiy(key);

// BeanFactory
public class BeanFactory {

   public static Properties env = new Properties();
   static {
       try {
           InputStream inputStream = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
           env.load(inputStream);

           inputStream.close();
       } catch (IOException e) {
           e.printStackTrace();
       }

   }


   public static UserService getUserService() {
       //创建对象的两种方式：1.new  2.反射
       UserService userService =  null;
       try {
           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;
   }
}

耦合转移至properties配置文件

问题：每需要一个对象就需要写一个工厂方法

解决方案：设计一个通用工厂，帮我们生产一切的对象

public class BeanFactory {

    public static Properties env = new Properties();
    static {
        try {
            InputStream inputStream = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
            env.load(inputStream);

            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

	//通用工厂
    public static Object getBean(String key) {
        Object ret = null;

        try {
            Class<?> clazz = Class.forName(env.getProperty(key));
            ret = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return ret;
    }
}


//测试方法
 @Test
    public void test() {

        //UserService userService = new UserServiceImpl();

        //UserService userService = BeanFactory.getUserService();

        UserService userService = (UserService) BeanFactory.getBean("userService");

        userService.login("jwww","123456");
    }

通⽤⼯⼚的使⽤⽅式

1. 定义类型 (类)
2. 通过配置⽂件的配置告知⼯⼚
(applicationContext.properties)
 key = value
3. 通过⼯⼚获得类的对象
 Object ret =
BeanFactory.getBean("key")

总结：

Spring本质：⼯⼚ ApplicationContext
(applicationContext.xml)

2、Spring程序

软件版本

JDK1.8+
2. Maven3.5+
3. IDEA2018+
4. SpringFramework 5.1.4
 官⽅⽹站 www.spring.io

环境搭建

spring的jar包

#设置pom 依赖
<!--https://mvnrepository.com/artifact/org.springframework/springcontext -->
<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>springcontext</artifactId>
 <version>5.1.4.RELEASE</version>
</dependency>

Spring的配置⽂件

1. 配置⽂件的放置位置：任意位置 没有硬性要求
2. 配置⽂件的命名 ：没有硬性要求 建议：applicationContext.xml
思考：⽇后应⽤Spring框架时，需要进⾏配置⽂件路径的设置。

Spring的核⼼API

ApplicationContext

作用：spring提供的ApplicationContext工厂，用于创建对象
好处：解耦合

ApplicationContext接口类型

接口：屏蔽实现的差异
实现类：
1. 非web环境（main、Junit）：ClassPathXMLApplicationContext
2. web环境：XMLWebApplicationContext

重量级资源

ApplicationContext⼯⼚的对象占⽤⼤量内存。不会频繁的创建对象 ： ⼀个应⽤只会创建⼀个⼯⼚对象。
ApplicationContext⼯⼚：⼀定是线程安全的(多线程并发访问)

程序开发

1. 创建类型
2. 配置配置文件：application.xml
    <bean id="person" class="com.jie.basic.Person"/>
3. 通过工厂获得对象
    ApplicationContext ctx = ClassPathXMLApplicationContext("/application.xml");
    Person person = (Person)ctx.getBean("person");

细节分析

名词解释

Spring⼯⼚创建的对象，叫做bean或者组件(componet)

Spring⼯⼚的相关的⽅法

//通过这种⽅式获得对象，就不需要强制类型转换
Person person =ctx.getBean("person",Person.class);
System.out.println("person = " +person);

//当前Spring的配置⽂件中 只能有⼀个<bean class是Person类型
Person person =ctx.getBean(Person.class);
System.out.println("person = " +person);

//获取的是 Spring⼯⼚配置⽂件中所有bean标签的id值 person person1
String[] beanDefinitionNames =ctx.getBeanDefinitionNames();
for (String beanDefinitionName :beanDefinitionNames) {
 System.out.println("beanDefinitionName = " +beanDefinitionName);
}

//根据类型获得Spring配置⽂件中对应的id值
String[] beanNamesForType =ctx.getBeanNamesForType(Person.class);
for (String id :beanNamesForType) {
 System.out.println("id = " +id);
}

//⽤于判断是否存在指定id值得bean
if
(ctx.containsBeanDefinition("a")
) {
 System.out.println("true = " +
true);
}else{
 System.out.println("false = "
+ false);
}

//⽤于判断是否存在指定id值得bean
if (ctx.containsBean("person"))
{
    System.out.println("true = " +true);
}else{
    System.out.println("false = "+ false);
}

配置⽂件中需要注意的细节

1. 只配置class属性
<beanclass="com.jie.basic.Person"/>
a) 上述这种配置 有没有id值com.jie.basic.Person#0
b) 应⽤场景： 如果这个bean只需要使⽤⼀次，那么就可以省略id值如果这个bean会使⽤多次，或者被其bean引⽤则需要设置id值
 
2. name属性
作⽤：⽤于在Spring的配置⽂件中，为bean对象定义别名(⼩名)
相同：
 1. ctx.getBean("id|name")-->object
 2. <bean id="" class=""等效<bean name="" class=""
区别：
 1. 别名可以定义多个,但是id属性只能有⼀个值
 2. XML的id属性的值，命名要求：必须以字⺟开头，字⺟ 数字 下划线 连字符不能以特殊字符开头 /person
 name属性的值，命名没有要求/person
 name属性会应⽤在特殊命名的场景下：/person (spring+struts1)    
 XML发展到了今天：ID属性的限制，不存在 /person
 
3. 代码
 //⽤于判断是否存在指定id值得bean,不能判断name值
 if(ctx.containsBeanDefinition("person")) {
 	System.out.println("true = " +true);
 }else{
   	System.out.println("false = " +false);
 }
 //⽤于判断是否存在指定id值得bean,也可以判断name值
 if(ctx.containsBean("p")) {
	System.out.println("true = " +true);
 }else{ 
     System.out.println("false = " +false);
 }

Spring⼯⼚的底层实现原理(简易版)

Spring⼯⼚是可以调⽤对象私有的构造⽅法创建对象(反射)

思考：

问题：未来在开发过程中，是不是所有的对象，都会交给Spring⼯⼚来创建呢？
回答：理论上 是的，
但是有特例 ：实体对象(entity)是不会交给Spring创建，它是由持久层框架进⾏创建。

Spring5.X与日志框架的整合

1. spring与日志框架整合就可以在控制台输出spring框架运行过程中的重要信息
2. 好处：利于理解spring框架运行原理和过程，更有利于调试和排错

整合

默认
 Spring1.2.3早期都是于commonslogging.jar
 Spring5.x默认整合的⽇志框架 logback log4j2

Spring5.x整合log4j
 1. 引⼊log4j jar包
 2. 引⼊log4.properties配置⽂件

pom

<dependency>
 <groupId>org.slf4j</groupId>
 <artifactId>slf4jlog4j12</artifactId>
 <version>1.7.25</version>
</dependency>
<dependency>
 <groupId>log4j</groupId>
 <artifactId>log4j</artifactId>
 <version>1.2.17</version>
</dependency>

log4j.properties

# resources # 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-ddHH:mm:ss} %-5p %c{1}:%L -%m%n

3、注⼊(Injection)

什么是注⼊

通过Spring⼯⼚及配置⽂件，为所创建对象的成员变量赋值

为什么需要注入？

//通过编码的⽅式，为成员变量进⾏赋值，存在耦合
ApplicationContext ctx = new ClassPathXMLApplication("/application.xml");
Person person = ctx.getBean("person");
person.setId(1);        //存在耦合
person.setName("jwww"); //应转移到配置文件，让spring为我们注入属性

如何进行注⼊[开发步骤]

类的成员变量提供set get⽅法

配置spring的配置⽂件

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

好处：解耦合

Spring注⼊的原理分析(简易版)

Spring通过底层调⽤对象属性对应的set⽅法，完成成员变量的赋值，这种方式我们也称之为set注⼊

4、Set注⼊详解

针对于不同类型的成员变量，在<property>标
签，需要嵌套其他标签
<property>
 xxxxx
</property>

JDK内置类型

String + 8种基本类型
```
<value>jie</value>
```

数组

<list>
   <value>jwww</value>
   <value>jie</value>
</list>

set集合

<set>
  <value>jwww</value>
   <value>jie</value>
</set>

<set>
  <<ref bean  存对象
  <set
</set>

list集合

<list>
     <value>11111</value>
     <value>2222</value>
</list>
<list>
     <ref bean
     <set
</list>

map集合

注意： map -- entry -- key有特定的标签 <key></key>
值根据对应类型选择对应类型的标签
<map>
     <entry>
         <key><value>jwww</value></key>
         <value>3434334343</value>
     </entry>
    
      <entry>
       <key><value>jie</value>
       </key> <ref bean
     </entry>
</map>

Properites

Properties类型 特殊的Map key=String value=String

<props>
     <prop key="key1">value1</prop>
     <prop key="key2">value2</prop>
</props>

复杂的JDK类型 (Date)

需要程序员⾃定义类型转换器，处理。

用户自定义类型

第⼀种⽅式

为成员变量提供set get⽅法
配置⽂件中进⾏注⼊(赋值)

<bean id="userService"class="xxxx.UserServiceImpl">
     <property name="userDAO">
     	<bean class="xxx.UserDAOImpl"/>
     </property>
</bean>

第⼀种赋值⽅式存在的问题

1. 配置⽂件代码冗余
2. 被注⼊的对象(UserDAO),多次创建，浪费（JVM)内存资源

为成员变量提供set get⽅法
配置⽂件中进⾏配置

<bean id="userDAO"class="xxx.UserDAOImpl"/>

<bean id="userService"class="xxx.UserServiceImpl">
         <property name="userDAO">
          < ref bean="userDAO"/>    直接引用创建好的bean
        </property>
</bean>

#Spring4.x 废除了 <ref local=""/> 基本等效 <ref bean=""/>

set注入简化写法

标签变为属性

注意：value属性 只能简化 8种基本类型+String 注⼊标签

JDK类型注⼊
<property name="name">
 	<value>jwww</value>
</property>
简化
<property name="name" value="jwww"/>

⽤户⾃定义类型
<property name="userDAO">
 	<ref bean="userDAO"/>
</property>
简化
<property name="userDAO" ref="userDAO"/>

p命名空间简化构造器注入

JDK类型注⼊
<bean id="person"class="xxxx.Person">
     <property name="name">
         <value>jwww</value>
     </property>
</bean>

<bean id="person"class="xxx.Person" p:name="jwww"/>

⽤户⾃定义类型
<bean id="userService"class="xx.UserServiceImpl">
     <property name="userDAO">
         <ref bean="userDAO"/>
     </property>
</bean>

<bean id="userService"class="xxx.UserServiceImpl" p:userDAO-ref="userDAO"/>

5、构造注⼊

1. 注⼊：通过Spring的配置⽂件，为成员变量赋值
2. Set注⼊：Spring调⽤Set⽅法 通过配置⽂件为成员变量赋值
3. 构造注⼊：Spring调⽤构造⽅法 通过配置⽂件 为成员变量赋值

开发步骤

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

spring配置文件

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

构造方法有重载怎么区分（配置文件如何正确匹配对应的构造函数）

1、构造函数参数个数不同时：通过参数个数匹配

2、参数个数相同时：通过添加type标签匹配

注⼊的总结

实战中，应⽤set注⼊还是构造注⼊？
答案：set注⼊更多
 1. 构造注⼊麻烦 (重载)
 2. Spring框架底层 ⼤量应⽤了set注⼊

6、反转控制与依赖注⼊

反转(转移)控制(IOC Inverse of Control)是什么？

1. 控制：对于成员变量赋值的控制权
2. 反转控制：把对于成员变量赋值的控制权，从代码中反转(转移)到Spring⼯⼚和配置⽂件中完成
3. 好处：解耦合
4. 底层实现：⼯⼚设计模式

依赖注入（Dependency Injection DI)是什么？

1. 注⼊：通过Spring的⼯⼚及配置⽂件，为对象（bean，组件）的成员变量赋值
2. 依赖注⼊：当⼀个类需要另⼀个类时，就意味着依赖，⼀旦出现依赖，就可以把另⼀个类作为本类的成员变量，最终通过Spring配置⽂件进⾏注⼊(赋值)。
3. 好处：解耦合
4. 依赖注入是一种思想，spring框架中到处都充满着这种思想

7、Spring⼯⼚创建复杂对象

什么是复杂对象？

//复杂对象：指的就是不能直接通过new构造⽅法创建的对象
 Connection：
  driver class.forName(String driver)
  con = DriverManager.getConnection(uri, username, password);
  
 SqlSessionFactory:
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream)

Spring⼯⼚创建复杂对象的3种⽅式

实现FactoryBean接口

Spring配置⽂件的配置

# 如果Class中指定的类型 是
FactoryBean接⼝的实现类，那么通过id值获得的是这个类所创建的复杂对象Connection
<bean id="conn"class="com.baizhiedu.factorybean.ConnectionFactoryBean"/>

细节
- 细节如果就想获得FactoryBean类型的对象 ctx.getBean("&conn") 获得就是 ConnectionFactoryBean对象
- isSingleton⽅法返回 true 只会创建⼀个复杂对象返回 false 每⼀次都会创建新的对象问题：根据这个对象的特点，决定是返回true (SqlSessionFactory) 还是 false (Connection) # 如果Class中指定的类型是 FactoryBean接⼝的实现类，那么通过 id值获得的是这个类所创建的复杂对象 Connection
- mysql⾼版本连接创建时，需要制定SSL证书，解决问题的⽅式
```
url ="jdbc:mysql://localhost:3306/suns?useSSL=false"
```
- 依赖注⼊的体会(DI)
```
把ConnectionFactoryBean中依赖的4个字符串信息 ，进⾏配置⽂件的注⼊
好处：解耦合
<bean id="conn"class="com.baizhiedu.factorybean.ConnectionFactoryBean">
 <property
    name="driverClassName"
    value="com.mysql.jdbc.Driver"/>
 <property name="url"
    value="jdbc:mysql://localhost:3306/suns?useSSL=false"/>
 <property name="username" value="root"/>
 <property name="password" value="123456"/>
</bean>
```

FactoryBean的实现原理[简易版]

接⼝回调
1. 为什么Spring规定FactoryBean接⼝实现 并且 getObject()?
2. ctx.getBean("conn") 获得是复杂对象 Connection ⽽没有 获得ConnectionFactoryBean(&)
Spring内部运⾏流程
1. 通过conn获得ConnectionFactoryBean类的对象 ，进⽽通过instanceof 判断出是FactoryBean接⼝的实现类
2. Spring按照规定 getObject() --->Connection
3. 返回Connection

FactoryBean总结

Spring中⽤于创建复杂对象的⼀种⽅式，也是Spring原⽣提供的，Spring整合其他框架，⼤量应⽤FactoryBean

实例⼯⼚

1. 避免Spring框架的侵⼊
2. 整合遗留系统

<bean id="connFactory"class="com.baizhiedu.factorybean.ConnectionFactory"></bean>
<bean id="conn" factorybean="connFactory" factorymethod="getConnection"/>

静态工厂

<bean id="conn"class="com.baizhiedu.factorybean.StaticConnectionFactory"factorymethod="getConnection"/>

Spring⼯⼚创建对象的总结

控制Spring⼯⼚创建对象的次数

如何控制简单对象的创建次数

<bean id="account"scope="singleton|prototype"class="xxxx.Account"/>
sigleton:只会创建⼀次简单对象 默认值
prototype:每⼀次都会创建新的对象

如何控制复杂对象的创建次数

FactoryBean{
     isSingleton(){
         return true 只会创建⼀次
         return false 每⼀次都会创建新的
     }
}
如没有isSingleton⽅法 还是通过scope属性 进⾏对象创建次数的控制

为什么要控制对象的创建次数？

好处：节省不别要的内存浪费

什么样的对象只创建⼀次？

1. SqlSessionFactory
2. DAO
3. Service  ...

什么样的对象每⼀次都要创建新的？

1. Connection
2. SqlSession | Session
3. Struts2 Action ...

posted @ 2021-10-01 09:02 jewww 阅读(95) 评论(0) 收藏举报

刷新页面返回顶部

下雨天

喜欢下雨天🌧️，因为它是适合发呆的天气。🍜

Spring -工厂

Spring -工厂

1、引言

EJB存在问题

什么是Spring？

设计模式又是什么？

Spring工厂

2、Spring程序

软件版本

环境搭建

Spring的配置⽂件

Spring的核⼼API

程序开发

细节分析

Spring⼯⼚的底层实现原理(简易版)

思考：

Spring5.X与日志框架的整合

3、注⼊(Injection)

什么是注⼊

为什么需要注入？

如何进行注⼊[开发步骤]

Spring注⼊的原理分析(简易版)

4、Set注⼊详解

JDK内置类型

用户自定义类型

set注入简化写法

5、构造注⼊

注⼊的总结

6、反转控制与依赖注⼊

反转(转移)控制(IOC Inverse of Control)是什么？

依赖注入（Dependency Injection DI)是什么？

7、Spring⼯⼚创建复杂对 象

什么是复杂对象？

Spring⼯⼚创建复杂对象的3种⽅ 式

实现FactoryBean接口

FactoryBean的实现原理[简易版]

FactoryBean总结

实例⼯⼚

静态工厂

Spring⼯⼚创建对象的总结

控制Spring⼯⼚创建对 象的次数

公告

7、Spring⼯⼚创建复杂对象

Spring⼯⼚创建复杂对象的3种⽅式

控制Spring⼯⼚创建对象的次数