JavaWeb - Sping & Sping IOC

• JavaWeb - Sping & Sping IOC
  • 1 Sping
    • 1.1 Sping 概念
      • 1.1.1 Sping 两大核心：
      • 1.1.2 耦合和解耦的概念
      • 1.1.3 Sping 的优点
  • 2 Spring IOC
    • 2.1 IOC的概念
    • 2.2 自定义IOC容器
    • 2.3 Sping 快速使用
    • 2.4 Spring API
      • 2.4.1 Spring 体系
      • 2.4.2 BeanFactory 接口
      • 2.4.3 ApplicationContext 接口
      • 2.4.4 BeanFactory 和 ApplicationContext 的区别
      • 2.4.5 常用方法 - getBean()
      • 2.4.6 Bean 标签配置
        • 2.4.6.1 Bean 标签的基本配置
        • 2.4.6.2 Bean 标签的范围配置
        • 2.4.6.3 Bean 生命周期的配置
        • 2.4.6.4 Bean 实例化的三种方式
      • 2.4.7 Bean 依赖注入
        • 2.4.7.1 Bean 依赖注入方式 - 构造方法
        • 2.4.7.3 Bean 依赖注入的的数据类型
      • 2.4.8 配置文件模块化
      • 2.4.9 Bean 标签配置，依赖注入和配置文件模块化小结
    • 2.5 DbUtils （IOC 实战）
    • 2.6 Spring 注解开发
      • 2.6.1 Spring 注解开发常用注解
        • 2.6.1.1 自定义类相关注解
        • 2.6.1.2 非自定义类和核心配置文件相关注解
      • 2.6.2 Spring 整合Junit

1 Sping

1.1 Sping 概念

Spring是分层的 Java SE/EE应用 full-stack(全栈式) 轻量级开源框架

• 全栈式：

  • 对各种主流技术和框架都进进行了整合，同时对三层架构都提供了解决方案

• 轻量级：

  • 轻量级和重量级的划分主要依据服务使用的多少，启动时资源加载的多少及耦合度等等

提供了表现层 SpringMVC

持久层 Spring JDBC Template

业务层事务管理，对象控制等众多的企业级应用技术

还能整合开源世界众多著名的第三方框架和类库

1.1.1 Sping 两大核心：

• IOC（Inverse Of Control：控制反转），把对象的创建权交给sping

• AOP（Aspect Oriented Programming：面向切面编程），在不修改源码的情况下对方法进行增强

1.1.2 耦合和解耦的概念

耦合：程序间的依赖关系

解耦：降低程序间的依赖关系，并不是完全消除

实例：

//1. 注册驱动 存在编译期依赖，这就是耦合重的体现
//new 关键字就会存在编译期依赖，解耦思路为去掉new改用反射
DriverManager.registerDriver(new com.mysql.jdbc.Driver());

解耦：使用反射机制让其编译期不依赖，运行期才依赖，但还存在硬编码问题
Class.forName("com.mysql.jdbc.Driver");

//最终解耦思路为：配置文件+反射，自定义IOC用到此思路

1.1.3 Sping 的优点

• 方便解耦，简化开发

  • Spring就是一个容器，可以将所有对象创建和关系维护交给Spring管理

• AOP编程的支持

  • Spring提供面向切面编程，方便实现程序进行权限拦截，运行监控等功能

• 声明式事务的支持

  • 通过配置完成事务的管理，无需手动编程

• 方便测试，降低JavaEE API的使用

  • Spring对Junit4支持，可以使用注解测试

• 方便集成各种优秀框架

  • 不排除各种优秀的开源框架，内部提供了对各种优秀框架的直接支持

2 Spring IOC

2.1 IOC的概念

控制反转（Inverse Of Control）不是什么技术，而是一种设计思想。它的目的是指导我们设计出更加松耦合的程序

• 控制：在java中指的是对象的控制权限（创建、销毁）
• 反转：指的是对象控制权由原来 由开发者在类中手动控制 反转到 由Spring容器控制

2.2 自定义IOC容器

核心思想为将对象的创建通过反射机制来实现进而实现解耦，再通过配置文件的方式来实现反射创建对象时产生的硬编码问题

步骤：

• 创建maven项目，导入需要使用包的坐标

<dependencies>
//dom4j 用来解析xml文件
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.6</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>

• 编写userDao接口及实现类，编写userService接口及实现类并在实现类中创建userDao实例对象并调用方法，最后编写测试类创建userService实例对象并调用方法
• 编写bean.xml 文件，将需要容器管理类编写到该文件中

<beans>
    <bean id = "userDao" class = "com.lagou.dao.userDaoImpl"></bean>
    <bean id="userService" class="com.lagou.service.userServiceImpl"></bean>
</beans>

• 编写BeanFactory工厂类，用来完成ioc容器的初始化加载和分配容器中的对象
  • 静态代码块用来加载配置文件并解析，获取到配置文件中类的路径和名称，再通过该路径来创建该类的对象
  • 声明一个Map类型的成员变量用来存储解类与其对应的对象
  • 声明一个方法用来通过类名获取对象

public class BeanFactory {
    private static Map<String, Object> ioc = new HashMap<>();

    static {
        try {
        //1.将xml文件读取，通过调用类加载器中的方法
            InputStream stream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
		//2.解析xml文件
            SAXReader saxReader = new SAXReader();

            Document document = saxReader.read(stream);
		//3.编写xpath来指定需要获取的标签
            String xpath = "//bean";
		//4.获取所有的bean 标签
            List<Element> list = document.selectNodes(xpath);
		//将标签中的元素取出并新建对象再放入集合中
            for (Element element : list) {
                ioc.put(element.attributeValue("id"),Class.forName(element.attributeValue("class")).newInstance());
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
//声明方法用来获取对象
    public static Object getBean(String id){
        return ioc.get(id);
    }
}

• 编写测试类

userService service = (userService) BeanFactory.getBean("userService");
        service.save();

2.3 Sping 快速使用

• 创建项目并导入相关坐标

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>

• 创建Sping 的核心配置文件，一般使用applicationContext.xml

// applicationContext.xml

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

</beans>

• 在核心配置文件中为Bean对象进行配置

<bean id="" class=""></bean>

• 创建ApplicationContext对象，执行getBean

ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
XXX xxx = (XXX) applicationContext.getBean("xxx");

2.4 Spring API

2.4.1 Spring 体系

2.4.2 BeanFactory 接口

BeanFactory是 IOC 容器的核心接口，它定义了IOC的基本功能

• 通过XmlBeanFactory 实现类来加载核心配置文件

BeanFactory beanFactory =
new XmlBeanFactory(new
ClassPathResource("applicationContext.xml"));

2.4.3 ApplicationContext 接口

代表应用上下文对象，可以获得spring中IOC容器的Bean对象

常用实现类：

• ClassPathXmlApplicationContext

  • 是从类的根路径下加载配置文件 推荐使用这种

• FileSystemXmlApplicationContext

  • 从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置

• AnnotationConfigApplicationContext

  • 使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解

ApplicationContext app =
new ClassPathXmlApplicationContext("applicationContext.xml");

2.4.4 BeanFactory 和 ApplicationContext 的区别

• BeanFactory 在第一次调用 getBean() 方法的时候创建指定对象的实例

//该语句执行并没有创建实例
new XmlBeanFactory(new ClassPathResource("xxx.xml"));

• ApplicationContext在启动容器时就加载和创建了所有对象的实例

2.4.5 常用方法 - getBean()

• Object getBean(String name);

  • 根据Bean的id从容器中获得Bean实例，返回是Object，需要强转

• T getBean(Class requiredType);

  • 根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错
  • 一个接口的每个实现类都需要在核心配置文件中配置
  • 对于有多个实现类的接口该方法不适用

• T getBean(String name,Class requiredType);

  • 根据Bean的id和类型获得Bean实例，解决容器中相同类型Bean有多个情况

2.4.6 Bean 标签配置

2.4.6.1 Bean 标签的基本配置

<bean id = "xxxService" class = "service 层里的实现类">
	<constructor-arg index="参数下标从0开始" type="构造方法参数接口类型" ref="构造方法参数bean id"/>
	或
	<constructor-arg name="构造方法参数的形参名" ref="构造方法参数bean id"/>
<bean/>

<bean id = "xxxService" class = "service层接口的实现类">
<property name = "set方法set后首字母小写" ref="属性对应接口Bean id"/>
<bean/>

xmlns:p="http://www.springframework.org/schema/p"

<bean id = "xxxService" class = "service层接口的实现类" p:xxxDao-ref="xxxDao/>

<property name="">
<list>
<value>基本数据类型的值<value/>
<ref bean = "引用数据类 Bean id"/>
<list/>
<property/>

<property name="">
<set>
<value>基本数据类型的值<value/>
<ref bean = "引用数据类 Bean id"/>
<set/>
<property/>

<property name="">
<array>
<value>基本数据类型的值<value/>
<ref bean = "引用数据类 Bean id"/>
<array/>
<property/>

<property name="">
<map>
<entry key="基本数据类型" value="基本数据类型">
<entry key-ref="引用数据类型Bean id" value-ref="引用数据类型Bean id">
<map/>
<property/>

<property name="">
<props>
<prop key="">值</prop>
<props/>
<property/>

ApplicationContext act =
new
ClassPathXmlApplicationContext("ApplicationContext.xml","xxx.xml","...");

<import resource="applicationContext-xxx.xml"/>

<bean>标签：创建对象并放到spring的IOC容器
id属性:在容器中Bean实例的唯一标识，不允许重复
class属性:要实例化的Bean的全限定名
scope属性:Bean的作用范围，常用是Singleton(默认)和prototype

<constructor-arg>标签：属性注入
name属性：属性名称
value属性：注入的普通属性值
ref属性：注入的对象引用值

<property>标签：属性注入
name属性：属性名称
value属性：注入的普通属性值
ref属性：注入的对象引用值
<list>
<set>
<array>
<map>
<props>

<import>标签:导入其他的Spring的分文件

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property> //特别注意该地方的set方法
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

在核心配置文件文件头中添加：
命名空间
xmlns:context="http://www.springframework.org/schema/context"

约束路径
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

标签内配置：
<context:property-placeholder location="classpath:jdbc.properties" />

<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

<!--注解的组件扫描-->
<context:component-scan base-package="com.lagou"></context:component-scan>

<dependency>
<groupId>javax.annotation</groupId>
<artifactId>javax.annotation-api</artifactId>
<version>1.3.2</version>
</dependency>

加载properties文件的配置：<context:property-placeholder location="classpath:jdbc.properties">

组件扫描的配置：<context:component-scan>

引入其他文件：<import>

new AnnotationConfigApplicationContext(核心配置文件.class);

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = {SpringConfig.class}) // 加载spring核心配置类

或

@ContextConfiguration(value = {"classpath:applicationContext.xml"}) //加载spring
核心配置文件

javax.net.ssl.SSLException: closing inbound before receiving peer's close_notify