Spring学习笔记

预备知识

1、什么是spring

1什么是Spring
Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转( IoC )和面向切面( AOP ).简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架
Spring主要的目的:简化企业开发

2、Spring核心

Spring的核心是控制反转( loC)和面向切面(AOP )。

1.2 Spring框架的优点

• 方便解耦，简化开发
  通过 Spring提供的loC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
• AOP编程的支持
  通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
• 声明式事务的支持
  在Spring 中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
• 方便程序的测试
  可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如:Spring 对Junit4支持，可以通过注解方便的测试Spring程序。
• 方便集成各种优秀框架
  Spring 不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架(如Struts,Hibernate、Hessian、Quartz )等的直接支持。
• 降低Java EE API的使用难度
  Spring对很多难用的Java EE API(如JDBc，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring 的简易封装，这些Java EE API的使用难度大为降低。
• . Java源码是经典学习范例
  Spring 的源码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring 框架源码无疑是Java技术的最佳
• 实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

3、初识spring

Spring一共有十几个组件，但是真正的核心组件只有几个，我们一起来看下Spring框架的总体架构图，了解一下他的体系结构。
从这个图中我们可以看出Spring框架的核心组件只有三个:Core、Context和Beans。他们构建起了整个Spring的骨骼架构，没有他们就不可能有AOP、Web等上层的特性功能。上面这些是Spring特性功能。

我列举了比较重要的几个包:AOP包(主要提供面向切面编程的实现)，Web(主要提供了Web应用开发的支持及针对Web应用的MVC思想实现)、ORM（为我们之前学的Hibernate，以及以后会学到的Mybatis这类持久化框架提供支持)、还有Spring MVC (这个是它自带的一个web视图层，可以替代到Sturts2，将来我们还会详细的学习这个SpringMVC框架)。。等等，其中最最核心的就是AOP和下面Spring核心包，也是我们学习的重点
1.4 Spring的两大核心技术
控制反转(IoC : lnversion of Control ) /依赖注入(DI : Dependency Injection )面向切面编程(AOP : Aspect Oriented Programming)

二、Spring入门程序

1、在pom.xml添加spring的相关依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>

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

2、在main/resources创建beans.xml文件（spring配置文件）

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

3、编写组件完成操作

package com.woniuxy;

public class HelloWorld {
   
    public String sayHello(String name){
   
        return "Hello"+name+"!";
    }
}

4、在Spring的配置文件中声明定义这个bean

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

<!--    如下结点相当于调用无参构造方法完成对象的实例化，HelloWorld helloworld=new HelloWorld()
        id:bean对象的唯一标识
        class：类全名
-->
    <bean id="hello" class="com.woniuxy.HelloWorld"></bean>
</beans>

5、测试

private Logger logger = Logger.getLogger(this.getClass());
@Test
public void testHelloworld()
{
   
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Object obj=context.getBean("hello");
    if (obj instanceof HelloWorld){
   
        HelloWorld hw=(HelloWorld) obj;
        logger.info(hw.sayHello("Spring "));
    }
}

三、Spring的核心容器

Spring提供了两种核心容器，分别是BeanFactory和ApplicationContext

1 、BeanFactory

BeanFactory是基础类型的STOC容器，它提供了完整的TOC服务支持，简单来说，BeanFacory就是一个管理Bean的工厂，它主要负责初始化各种Bean,并调用它们的生命周期方法

BeanFactory接口有多个实现类，最常见的是XmlBeanFactory

@Test
public void testBeanFactory(){
   
    BeanFactory factory = new XmlBeanFactory(new FileSystemResource("E:\\IDEA\\WN-Spring\\spring-01-quickstart\\src\\main\\resources\\beans.xml"));
    Object obj=factory.getBean("hello");
    if(obj instanceof HelloWorld){
   
        HelloWorld hw=(HelloWorld) obj;
        logger.info(hw.sayHello("Giles"));
    }
}

2、ApplicationContext

AppicationContext是BeanFactory的子接口，ApplicationContext不仅包含了BeanFactory的所有功能，还添加了对国际化，资源访问，事件传播等方面的支持ApplicationContext接口有两个常用的实现类，具体如下所示

. ClassPathXmlApplicationContext:该类从类路径中寻找指定的XML配置文件

. FileSystemXmlApplicationContext:该类从指定的文件系统中寻找指定的XML配置文件

在WEB项目中，, ApplicationContext容器的实例化工作会交由WEB服务器完成，WEB服务器实例化ApplicationContext容器通常使用基于ContextLoaderlistener实现的方式，它需要在web.xml中添加如下代码

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value></context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

3 BeanFactory和ApplicationContext的主要区别:

如果Bean的某一个属性没有注入，则使BeanFactory加载后，在第一次调用getBean()方法时会抛出异常
而ApplicationContext则在初始化时自检，这样有利于检
查所依赖的属性是否注入。
因此，在实际开发过程中，通常都选择使用ApplicationContext，而只有在系统资源较少时，才考虑使用BeanFactory。

四、Spring IOC和DI概念理解（重中之重）

1、IOC（控制反转）降低程序的耦合性

（1）IOC(控制翻转)控制反转(IOC )
依赖注入( Dependency Injection,简称DI )
IOC和DI是一回事，只是在不同的角度去诠释同一个问题1）控制反转(IOC )

使用Spring之前

使用Spring之后

由代码来维护程序之间的关系，有了spring容器之后，程序之间的这种关系，控制权由应用程序转移到到了Spring容器，控制器权发生了反转，这就是spring的控制反转，称为IOC

DI(依赖注入)

从另外一个角度来说明

所谓的依赖注入：在程序运行的过程中临时组装各组件（各组件之间要有合适的接口）

思考：是不是所有的组件都需要放在Spring容器中来管理？不是的

五、依赖注入的实现方式

有两种放心可以进行注入，setter方式(使用更多)，构造方法注入

1、SET方式的注入

1）、基本数据类型的注入

简单数据类型

|–基本数据类型： byte、short、int、long、float、double、Boolean、char

|–引用数据类型String

使用value属性或者value来实现注入的

pojo实体类：

public class Student {
   
    private String name;
    private int age;

    public void setName(String name) {
   
        this.name = name;
    }

    public void setAge(int age) {
   
        this.age = age;
    }

    @Override
    public String toString() {
   
        return "name:"+name+"年龄"+age;
    }
}

beans.xml配置

<!--    简单类型的注入-->
    <bean id="student1" class="com.woniuxy.pojo.Student">
        <property name="name" value="张三"></property>
        <property name="age">
            <value>18</value>
        </property>
    </bean>
<!--
        如果遇到特殊字符，XML中的解决办法有两种
        1、通过转义字符：比如：P&amp;G
        2、通过<!CDATA[]>方式来进行转义

-->
    <bean id="student2" class="com.woniuxy.pojo.Student">
        <property name="name" value="P&amp;G"></property>
        <property name="age" value="16"></property>
    </bean>

    <bean id="student3" class="com.woniuxy.pojo.Student">
        <property name="name">
            <value><![CDATA[P&G]]></value>
        </property>
        <property name="age" value="16"></property>
    </bean>

测试：

public void testDi1()
{
   
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Student student= (Student) context.getBean("student1");
    logger.info(student);
}

2）注入bean对象类型

package com.woniuxy.pojo;

import lombok.Data;

import java.io.Serializable;
import java.util.List;

@Data
public class Dept implements Serializable{
   
    private byte deptno;
    private String dname;
    private String loc;
    private List<Emp> emps;
}

package com.woniuxy.pojo;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

@Data
public class Emp implements Serializable{
   
    private short empno;
    private String ename;
    private String job;
    private short mgr;
    private Date hiredate;
    private double sal;
    private double comm;
    private Dept dept;
}

package com.woniuxy.dao;

import com.woniuxy.pojo.Dept;