男儿西北有神州，莫滴水西桥畔泪

1. 分层开发

* 表现层
  * 直接和用户打交道，大部分跟界面有关（html，jsp，servlet）
* 服务层
  * 指业务逻辑，业务逻辑由一个到多个基本的增删改查组成
* 持久层（数据访问层）
  * 将数据永久的保存，jdbc，mybatis

2. spring 框架

将其他框架进行整合，便于开发，提高程序的扩展性
声明式的事务管理
就是指不需要编写代码进行事务控制了，可以 xml 配置文件，或是用注解实现事务控制
编程式的事务管理
connection.setAutoCommit(false);
connection.commit();
connection.rollback();

3. spring 框架的核心思想

IOC inversion of controll (控制反转)

servlet java 类

public class MyServlet extends HttpServlet {
```
 service
 doGet
 doPost
```
}
// 并不需要自己创建它的实例对象， tomcat 是servlet的运行环境，由 tomcat 来创建 MyServlet 的实例对象, 负责调用 servlet 中的方法
new MyServlet();
.service

// tomcat 容器

所谓的控制反转，就是把对象的一些控制权（对象的创建、一些方法的调用）都交给容器来完成。

对刚才的例子，就是把 servlet 控制权交给了 tomcat 容器
以后可以把很多对象的控制权交给 spring 容器来管理，包括对象的创建、对象的生命周期、对象的个数、对象的依赖关系
AOP aspect oriented programming (面向切面编程)
OOP object oriented programming (面向对象编程)

4. spring 中 IOC

添加spring依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.22.RELEASE</version>
</dependency>

编写spring的配置文件
提供一个 xml 的配置文件，放在 main/resources 下

<?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">

    <!-- spring 的配置 -->
</beans>

编写一个java 类交给spring容器管理
使用了一个 bean 标签把某个类交给spring容器管理

<bean id="userService" class="service.UserService"></bean>

使用 userService

// 1. 创建 spring 容器
// 类路径（对maven项目 java 和 resources) application 应用程序 context 容器
ClassPathXmlApplicationContext context =
        new ClassPathXmlApplicationContext("spring.xml");

// 2.1 根据 id 获取容器中的对象
UserService service = (UserService)
        context.getBean("userService");

// 2.2 根据 类型 获取容器中的对象
UserService service2 = context.getBean(UserService.class);

// 原来的手段：
// UserService service3 = new UserService();

// 3. 使用对象
service.insert(new User());

5. spring 容器控制反转都能控制哪些方面

5.1 对象的个数

默认情况下，spring 中的每个 bean 标签只会创建一个对象(单例)
可以通过配置来实现多例子

<!-- 其中 prototype是多例， singleton是单例(默认值) -->
<bean scope="prototype|singleton">

5.2 对象的生命周期方法

对于单例对象来讲，容器一创建，就会创建这些单例对象，并且随后就调用他们的初始化方法, 并且容器 close 时，会调用他们的销毁方法
每次使用多例时，就会创建新的对象，并调用他们的初始化方法，多例对象不会调用销毁方法

配置初始化

<bean init-method="初始化方法名">

配置销毁

<bean destroy-method="销毁方法名">

5.3 控制懒惰初始化

默认是false（非懒惰）, 改为 true 表示（懒惰）

<bean lazy-init="true">
<!-- 全局配置 -->
<beans default-lazy-init="true">

5.4 对象之间的依赖关系

例如，管理 service 和 dao 之间的依赖关系

<bean id="userService">
    <!-- property 标签用来给对象的属性赋值 name="属性名" ref="引用id" -->
    <property name="userDao" ref="userDao"/>
</bean>

<bean id="userDao">
</bean>

记得要给属性提供一个公共的 setter 方法

降低耦合度：层与层之间，要依赖接口，而不要依赖于具体实现；配合 spring 的控制反转真正实现低耦合

6. 依赖注入

6.1 依赖注入的两种方式

DI (dependency inject) - 建立对象之间依赖关系的过程和方式

把userService 需要的 userDao 注入给 userService 的属性

常见的方式：

set 方法注入，spring调用set方法来完成对属性的赋值

<property name="属性名" ref="引用id"/>

构造方法注入，spring调用构造构造方法完成对属性的赋值

<constructor-arg index="下标" ref="引用id"/>

6.2 简化注入的办法

autowired 自动织入 - 要么根据名字匹配，要么根据类型匹配

<!-- 根据属性名字查找容器中的bean，找到了就进行依赖注入, 可以唯一确定容器中的bean -->
<bean autowire="byName">
</bean>

<!-- 根据属性类型查找容器中的bean，找到了就进行依赖注入, 如果容器中有多个类型相同的bean， byType就不适用了 -->
<bean autowire="byType">
</bean>

注解方式的注入
@Autowired 可以加在要注入的属性上，也可以加在属性对应的set方法或构造方法上，底层根据 byType 进行匹配注入

6.3 值注入

可以使用

<property name="属性名" value="值" />
<constructor-arg index="下标" value="值"/>

注解值注入
@Value(“值”) – 不推荐直接给值
@Value("${key}") – 引用外部配置文件（*.properties）中的值, 根据这个key 到 properties 文件中找相应的值

需要在spring.xml 中配置此 properties 文件

<context:property-placeholder location="classpath:文件的位置">

7 实际例子

7.1 spring 管理连接池

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/test"/>
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
    <property name="maxActive" value="10"/>
    <property name="minIdle" value="2"/>
</bean>

HikariCP 国外的 - 速度比较快
Druid 阿里的 - 为监控sql而生

HikariDataSource

8. 在spring之前，可以使用工厂方法+接口+配置文件的方式实现解耦合(见Day40Spring3项目)

spring中的做法

@Autowired
private UserDao userDao; // 被动获取，依赖注入

工厂方法的做法

private UserDao userDao = UserDaoFactory.getUserDao(); // 主动获取, 一般不管依赖关系

Spring框架