引言
- 什么是 Spring?
- ⼯⼚设计模式
  - 简单工厂的设计
Properties 集合存储 Properties文件的内容
特殊Map key=String value=String
Properties [userService = com.baizhiedu.xxx.UserServiceImpl]
Properties.getProperty(“userService”)
Properties 集合存储 Properties文件的内容
特殊Map key=String value=String
Properties [userService = com.baizhiedu.xxx.UserServiceImpl]
Properties.getProperty(“userService”)
- 配置文件中的细节
Spring⼯⼚的底层实现原理(简易版)
思考
Spring5.x 与日志框架的整合

引言

EJB（Enterprise Java Bean）存在的问题：EJB 是重量级的框架。

运行环境苛刻
代码移植性差

什么是 Spring?
Spring是⼀个轻量级的 JavaEE 解决⽅案，整合众多优秀的设计模式。
什么是轻量级?
对于运⾏环境是没有额外要求的；
开源：tomcat、resion、jetty
收费：weblogic、websphere
代码移植性⾼：不需要实现额外接⼝。

JavaEE 的解决方案：
Spring 工厂 - 图1
整合设计模式：

⼯⼚
代理
模板
策略

什么是设计模式？

⼴义概念：⾯向对象设计中，解决特定问题的经典代码。
狭义概念：GOF4⼈帮定义的23种设计模式：⼯⼚、适配器、装饰器、⻔⾯、代理、模板…
⼯⼚设计模式
什么是⼯⼚设计模式？

概念：通过⼯⼚类，创建对象；

User user = new User();
UserDAO userDAO = new UserDAOImpl();

好处：解耦合。

耦合：指定是代码间的强关联关系，⼀⽅的改变会影响到另⼀⽅；
问题：不利于代码维护；
简单：把接⼝的实现类，硬编码在程序中；

UserService userService = new UserServiceImpl();

简单工厂的设计

``` package com.baizhiedu.basic; import java.io.IOException; import java.io.InputStream; import java.util.Properties; public class BeanFactory { private static Properties env = new Properties();

static{

  try {
      //第一步 获得IO输入流
      InputStream inputStream = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
      //第二步 文件内容 封装 Properties集合中 key = userService value = com.baizhixx.UserServiceImpl
      env.load(inputStream);
      inputStream.close();
  } catch (IOException e) {
      e.printStackTrace();
  }

}

 对象的创建方式：
     1. 直接调用构造方法 创建对象  UserService userService = new UserServiceImpl();
     2. 通过反射的形式 创建对象 解耦合
     Class clazz = Class.forName("com.baizhiedu.basic.UserServiceImpl");
     UserService userService = (UserService)clazz.newInstance();

*/ public static UserService getUserService() {

  UserService userService = null;
  try {
      //com.baizhiedu.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;

} }


配置文件 applicationContext.properties：

Properties 集合存储 Properties文件的内容

特殊Map key=String value=String

Properties [userService = com.baizhiedu.xxx.UserServiceImpl]

Properties.getProperty(“userService”)

userService = com.baizhiedu.basic.UserServiceImpl userDAO = com.baizhiedu.basic.UserDAOImpl

<a name="EFB01"></a>
### 通⽤⼯⼚的设计
问题：简单⼯⼚会存在⼤量的代码冗余。<br />![](https://cdn.nlark.com/yuque/0/2020/png/419703/1599405272608-d165a464-86de-44cb-8fd4-066ad063b216.png#align=left&display=inline&height=691&margin=%5Bobject%20Object%5D&originHeight=691&originWidth=746&size=0&status=done&style=none&width=746)
通⽤⼯⼚的代码：

package com.baizhiedu.basic; import java.io.IOException; import java.io.InputStream; import java.util.Properties; public class BeanFactory { private static Properties env = new Properties(); static{ try { //第一步获得IO输入流 InputStream inputStream = BeanFactory.class.getResourceAsStream(“/applicationContext.properties”); //第二步文件内容封装 Properties集合中 key = userService value = com.baizhixx.UserServiceImpl env.load(inputStream); inputStream.close(); } catch (IOException e) { e.printStackTrace(); } }

 /*
  key 小配置文件中的key [userDAO,userService]
  */
 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;
 }

}


配置文件 applicationContext.properties：

Properties 集合存储 Properties文件的内容

特殊Map key=String value=String

Properties [userService = com.baizhiedu.xxx.UserServiceImpl]

Properties.getProperty(“userService”)

userService = com.baizhiedu.basic.UserServiceImpl userDAO = com.baizhiedu.basic.UserDAOImpl

<a name="iwe2N"></a>
### 通⽤⼯⼚的使⽤⽅式
1. 定义类型 (类)
1. 通过配置⽂件的配置告知⼯⼚<br />`applicationContext.properties` 中 `key = value`；
1. 通过⼯⼚获得类的对象<br />`Object ret = BeanFactory.getBean("key");`
**总结**：<br />**Spring本质**：⼯⼚ ApplicationContext (applicationContext.xml)
<a name="26dGE"></a>
# 第一个 Spring 程序
<a name="07oBb"></a>
## 环境搭建
依赖查询网站：[https://mvnrepository.com/](https://mvnrepository.com/)；<br />**配置 Spring 的 jar 包：**

org.springframework spring-context 5.1.4.RELEASE

**<br />**Spring 的配置文件：**
1. 配置⽂件的放置位置：任意位置，没有硬性要求；
1. 配置⽂件的命名 ：没有硬性要求，建议：**applicationContext.xml**；
思考：⽇后应⽤ Spring 框架时，需要进⾏配置⽂件路径的设置，一般都是放置在 resources 目录下。<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/419703/1599406263363-da675aa6-861a-4a15-9d9b-112b4af4233c.png#align=left&display=inline&height=43&margin=%5Bobject%20Object%5D&name=image.png&originHeight=43&originWidth=418&size=4700&status=done&style=none&width=418)
<a name="gBxpW"></a>
## Spring 的核⼼API
`ApplicationContext`
- 作⽤：Spring 提供的 `ApplicationContext` 这个⼯⼚，⽤于对象的创建；<br />好处：解耦合
- `ApplicationContext` 是接⼝类型；<br />接⼝：屏蔽实现的差异<br />⾮web环境 (main junit) ：`ClassPathXmlApplicationContext`<br />web环境 ：`XmlWebApplicationContext`<br />![](https://cdn.nlark.com/yuque/0/2020/png/419703/1599405272638-3f150282-5144-4bcb-9911-9929629a2380.png#align=left&display=inline&height=719&margin=%5Bobject%20Object%5D&originHeight=719&originWidth=836&size=0&status=done&style=none&width=836)
- 重量级资源：<br />`ApplicationContext` ⼯⼚的对象占⽤⼤量内存。<br />不会频繁的创建对象 ，⼀个应⽤只会创建⼀个⼯⼚对象。<br />`A pplicationContext` ⼯⼚：⼀定是线程安全的(多线程并发访问)。
<a name="WHcVX"></a>
## 程序开发
1. 创建类型：Person.java
```java
public class Person {}

配置文件的配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
     <bean id="person" class="com.yusael.basic.Person"/>
</beans>

通过⼯⼚类，获得对象 ```java /**
- 用于测试Spring的第一个程序 */ @Test public void test() { // 1、获取spring的工厂 ApplicationContext ctx = new ClassPathXmlApplicationContext(“/applicationContext.xml”); // 2、通过工厂类获得对象 Person person = (Person)ctx.getBean(“person”); System.out.println(person); }

<a name="fCgwI"></a>
## 细节分析
名词解释：Spring ⼯⼚创建的对象，叫做 bean 或者 组件(componet)；
<a name="U73or"></a>
### Spring ⼯⼚的相关的⽅法
`getBean`：传入 id 值 和 类名 获取对象，不需要强制类型转换。
```java
// 通过这种⽅式获得对象，就不需要强制类型转换
Person person = ctx.getBean("person", Person.class);
System.out.println("person = " + person);

getBean：只指定类名，Spring 的配置文件中只能有一个 bean 是这个类型。

// 使用这种方式的话, 当前Spring的配置文件中 只能有一个bean class是Person类型
Person person = ctx.getBean(Person.class);
System.out.println("person = " + person);

getBeanDefinitionNames：获取 Spring 配置文件中所有的 bean 标签的 id 值。

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

getBeanNamesForType：根据类型获得 Spring 配置文件中对应的 id 值。

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

containsBeanDefinition：用于判断是否存在指定 id 值的 bean，不能判断 name 值。

// 用于判断是否存在指定id值的bean,不能判断name值
if (ctx.containsBeanDefinition("person")) {
    System.out.println(true);
} else {
    System.out.println(false);
}

containsBean：用于判断是否存在指定 id 值的 bean，也可以判断 name 值。

// 用于判断是否存在指定id值的bean,也可以判断name值
if (ctx.containsBean("p")) {
    System.out.println(true);
} else {
    System.out.println(false);
}

配置文件中的细节

如果 bean 只配置 class 属性：

<bean class="com.yusael.basic.Person"></bean>

会自动生成一个 id，com.yusael.basic.Person#1
可以使用 getBeanNamesForType 验证。
应⽤场景：
如果这个 bean 只需要使⽤⼀次，那么就可以省略 id 值；
如果这个 bean 会使⽤多次，或者被其他 bean 引⽤则需要设置 id 值；

name 属性：

作⽤：⽤于在 Spring 的配置⽂件中，为 bean 对象定义别名（小名）
name 与 id 的相同点：
- ctx.getBean("id") 或 ctx.getBean("name") 都可以创建对象；、
- <bean id="person" class="Person"/> 与 <bean name="person" class="Person"/> 等效；
name 与 id 的区别：
- name 别名可以定义多个（中间用”,”隔开），但是 id 属性只能有⼀个值；
- XML 的 id 属性的值，命名要求：必须以字⺟开头，可以包含字⺟、数字、下划线、连字符；不能以特殊字符开头 /person；
  XML 的 name 属性的值，命名没有要求，/person 可以。
  但其实 XML 发展到了今天：ID属性的限制已经不存在，/person也可以。
  Spring⼯⼚的底层实现原理(简易版)
  
  思考
  问题：未来在开发过程中，是不是所有的对象，都会交给 Spring ⼯⼚来创建呢？
  回答：理论上是的，但是有特例：实体对象(entity) 是不会交给Spring创建，它由持久层框架进⾏创建。
  Spring5.x 与日志框架的整合
  Spring 与⽇志框架进⾏整合，⽇志框架就可以在控制台中，输出Spring框架运⾏过程中的⼀
  些重要的信息。
  好处：便于了解Spring框架的运⾏过程，利于程序的调试。
  
  默认日志框架 Spring 1.x、2.x、3.x 早期都是基于commonslogging.jar Spring 5.x 默认整合的⽇志框架 logback、log4j2

Spring 如何整合⽇志框架？
Spring5.x 整合 log4j：

引⼊ log4j.jar 包；

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>

引⼊ log4.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

Spring 工厂

引言

什么是 Spring?

⼯⼚设计模式

简单工厂的设计

Properties 集合 存储 Properties文件的内容

特殊Map key=String value=String

Properties [userService = com.baizhiedu.xxx.UserServiceImpl]

Properties.getProperty(“userService”)

Properties 集合 存储 Properties文件的内容

特殊Map key=String value=String

Properties [userService = com.baizhiedu.xxx.UserServiceImpl]

Properties.getProperty(“userService”)

配置文件中的细节

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

思考

Spring5.x 与 日志框架 的整合

Properties 集合存储 Properties文件的内容

Properties 集合存储 Properties文件的内容

Spring5.x 与日志框架的整合