Spring入门

1、Spring

        1.1、什么是Spring

        Spring 是一款目前主流的 Java EE 轻量级开源框架 ，是 Java 世界最为成功的框架之一。Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。

Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然成为了 Java EE 代名词，成为了构建 Java EE 应用的事实标准。

Spring 框架不局限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。Spring 框架还是一个超级粘合平台，除了自己提供功能外，还提供粘合其他技术和框架的能力。

Spring 框架是一个分层的、面向切面的 Java 应用程序的一站式轻量级解决方案，它是 Spring 技术栈的核心和基础，是为了解决企业级应用开发的复杂性而创建的。

简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。介于SpringMVC与Mybatis之间的中间层框架，作用：承上启下，相当于粘合剂

核心	描述
IOC	Inverse of Control 的简写，译为“控制反转”，指把创建对象过程交给 Spring 进行管理。
AOP	Aspect Oriented Programming 的简写，译为“面向切面编程”。 AOP 用来封装多个类的公共行为，将那些与业务无关，却为业务模块所共同调用的逻辑封装起来，减少系统的重复代码，降低模块间的耦合度。另外，AOP 还解决一些系统层面上的问题，比如日志、事务、权限等。

        1.2、Spring的核心框架

Spring Core：提供依赖注入和Bean管理功能，主要组件是 BeanFactory，它使用控制反转模式将应用程序配置和依赖规范与实际的应用代码分开；

Spring Context：扩展了BeanFactory的概念，增加了对国际化、事件传播，以及验证等的支持，此外还提供了许多企业服务及对模版框架集成的支持；

Spring Web：建立于Context模块之上，提供了一个适合于Web应用的上下文。另外，这个模块还提供了一些面向服务支持，也提供了Spring和其它Web框架的集成；

Spring Web MVC：是一个全功能的构建 Web 应用程序的 MVC 实现，容纳了大量视图技术，如 JSP、Velocity、POI等；

Spring AOP：为Spring容器管理的对象提供了对面向切面编程的支持；

Spring DAO：该层封装了对数据库的访问，并且处理了其抛出的错误消息，同时还基于AOP模块提供了事务管理；

Spring ORM（Object Relational Mapping）：Spring支持多种ORM框架（Mybatis、Hibernate），简化了数据库操作。

        1.3、Spring的特点

1）方便解耦，简化开发

Spring 就是一个大工厂，可以将所有对象的创建和依赖关系的维护交给 Spring 管理。

2）方便集成各种优秀框架

Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如 Struts2、Hibernate、MyBatis 等）的直接支持。

3）降低 Java EE API 的使用难度

Spring 对 Java EE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等）都提供了封装，使这些 API 应用的难度大大降低。

4）方便程序的测试

Spring 支持 JUnit4，可以通过注解方便地测试 Spring 程序。

5）AOP 编程的支持

Spring 提供面向切面编程，可以方便地实现对程序进行权限拦截和运行监控等功能。

6）声明式事务的支持

只需要通过配置就可以完成对事务的管理，而无须手动编程。

2、什么是控制反转(或依赖注入)

        2.1、控制反转IOC（下面红色字体是容易理解的地方）

        在传统的 Java 应用中，一个类想要调用另一个类中的属性或方法，通常会先在其代码中通过 new Object() 的方式将后者的对象创建出来，然后才能实现属性或方法的调用。为了方便理解和描述，我们可以将前者称为“调用者”，将后者称为“被调用者”。也就是说，调用者掌握着被调用者对象创建的控制权。

但在 Spring 应用中，Java 对象创建的控制权是掌握在 IoC 容器手里的，其大致步骤如下。

1. 开发人员通过 XML 配置文件、注解、Java 配置类等方式，对 Java 对象进行定义，例如在 XML 配置文件中使用 <bean> 标签、在 Java 类上使用 @Component 注解等。

2. Spring 启动时，IoC 容器会自动根据对象定义，将这些对象创建并管理起来。这些被 IoC 容器创建并管理的对象被称为 Spring Bean。

3. 当我们想要使用某个 Bean 时，可以直接从 IoC 容器中获取（例如通过 ApplicationContext 的 getBean() 方法），而不需要手动通过代码（例如 new Obejct() 的方式）创建。

IoC 带来的最大改变不是代码层面的，而是从思想层面上发生了主从换位的改变。原本调用者是主动的一方，它想要使用什么资源就会主动出击，自己创建；但在 Spring 应用中，IoC 容器掌握着主动权，调用者则变成了被动的一方，被动的等待 IoC 容器创建它所需要的对象（Bean）。

这个过程在职责层面发生了控制权的反转，把原本调用者通过代码实现的对象的创建，反转给 IoC 容器来帮忙实现，因此我们将这个过程称为 Spring 的“控制反转”。

总的来说，控制反转(IoC=Inversion of Control)IoC，用白话来讲，就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：(依赖)控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。

        2.2、什么是依赖注入DI

        在面向对象中，对象和对象之间是存在一种叫做“依赖”的关系。简单来说，依赖关系就是在一个对象中需要用到另外一个对象，即对象中存在一个属性，该属性是另外一个类的对象。

例如，有一个名为 UserBizImpl 的 Java 类，它的代码如下。

public class UserBizImpl {
    private IUserDao userDao=new UserDaoImpl();
    public User selectOne(Integer userId){
        return userDao.selectOne(userId);
    }
}

从代码可以看出，UserBizImpl中存在一个 userDao的对象，此时我们就可以说 UserBizImpl 的对象依赖于对象 userDao。而依赖注入就是基于这种“依赖关系”而产生的。

控制反转核心思想就是由 Spring 负责对象的创建。在对象创建过程中，Spring 会自动根据依赖关系，将它依赖的对象注入到当前对象中，这就是所谓的“依赖注入”。

即由Spring IOC容器动态的将某种依赖关系注入到组件之中

3、Spring之IOC入门

        3.1、基于idea创建Maven项目导入spring相关依赖（spring-core、spring-context）在pom.xml文件下。

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>自己的项目名，会自动生成</groupId>
  <artifactId>Spring-01</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>Spring-01 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <!-- junit_version-->
    <junit.version>4.11</junit.version>
    <!--    servlet_version-->
    <servlet.version>4.0.1</servlet.version>
    <!--    Spring_version-->
    <spring.version>5.0.1.RELEASE</spring.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>Spring-01</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.7.0</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

        3.2、在src/main/resources/目录下创建spring.xml文件

        3.3、创建实体类：如图

        类中编写如下代码

package com.zking.entity;

public class Spring_jiang {
    private String jname;

    public String getJname() {
        return jname;
    }

    public void setJname(String jname) {
        this.jname = jname;
    }

    public Spring_jiang() {
        System.out.println("创建了对象");
    }
}

                3.4、编写Spring.xml对应代码(在Spring.xml文件中创建Bean，然后它就会在运行项目时，通过上面的web.xml文件将Bean的相关内容以及属性进行赋值给到对应的Bean)

Bean元素的常用属性

属性	描述
id	Bean 的唯一标识符，Spring 容器对 Bean 的配置和管理都通过该属性完成。id 的值必须以字母开始，可以使用字母、数字、下划线等符号。
name	name 属性中可以为 Bean 指定多个名称，每个名称之间用逗号或分号隔开。Spring 容器可以通过 name 属性配置和管理容器中的 Bean。
class	该属性指定了 Bean 的具体实现类，它必须是一个完整的类名，即类的全限定名。
scope	用于设定 Bean 实例的作用域，属性值可以为 singleton（单例）、prototype（原型）、request、session 和 global Session。其默认值是 singleton
constructor-org	<bean>元素的子元素，可以使用此元素传入构造参数进行实例化。该元素的 index 属性指定构造参数的序号（从 0 开始），type 属性指定构造参数的类型
property	<bean>元素的子元素，用于调用 Bean 实例中的 setter 方法来属性赋值，从而完成依赖注入。该元素的 name 属性用于指定 Bean 实例中相应的属性名
ref	<property> 和 <constructor-arg> 等元素的子元素，该元素中的 bean 属性用于指定对某个 Bean 实例的引用
value	<property> 和 <constractor-arg> 等元素的子元素，用于直接指定一个常量值
list	用于封装 List 或数组类型的依赖注入
set	用于封装 Set 类型的依赖注入
map	用于封装 Map 类型的依赖注入
entry	元素的子元素，用于设置一个键值对。其 key 属性指定字符串类型的键值，ref 或 value 子元素指定其值
init-method	容器加载 Bean 时调用该方法，类似于 Servlet 中的 init() 方法
destory-method	容器删除 Bean 时调用该方法，类似于 Servlet 中的 destroy() 方法。该方法只在 scope=singleton 时有效
lazy-init	懒加载，值为 true，容器在首次请求时才会创建 Bean 实例；值为 false，容器在启动时创建 Bean 实例。该方法只在 scope=singleton 时有效

<?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="spring_j" class="com.zking.entity.Spring_jiang">
        <property name="jname" value="姜某某"/>
    </bean>

</beans>

        3.5、创建测试类Demo代码如下（就可以通过IOC容器获取Bean的对应属性的值）

package com.zking.util;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Arrays;

public class Dmeo {
    public static void main(String[] args) {
        //Spring IOC框架
        ApplicationContext as = new ClassPathXmlApplicationContext("Spring.xml");
        //配置方式不只上面一种
        方式二：一次加载多个配置文件，数组方式
        //ApplicationContext ac=new ClassPathXmlApplicationContext(new String[]{"spring-mybatis.xml","spring-redis.xml"});

        //方式三：使用*通配符方式
        //ApplicationContext ac=new ClassPathXmlApplicationContext("classpath:spring-*.xml");
        //获取对象
        Spring_jiang sj = as.getBean("spring_j", Spring_jiang.class);
        System.out.println(sj.getJname());
    }
}

          3.6、ref引用

        创建外部spring配置文件spring-address.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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
​
    <bean id="address" class="com.zking.spring01.entity.Address">
        <property name="city">
            <value>长沙</value>
        </property>
    </bean>
</beans>

通过import标签引入到spring.xml中，并使用<ref/>标签引入spring-address.xml文件中定义的bean。

<import resource="spring-address.xml"/>
...
<bean id="student3" class="com.zking.spring01.entity.Student">
    <property name="age">
        <value>20</value>
    </property>
    <property name="address">
        <ref bean="address"/>
    </property>
</bean>

          3.7、复杂类型注入

在Student实体类中新增List、Map、Properties、数组类型

public class Student{
​
    private List lst;
    private Map map;
    private Properties prop;
    private String[] arr;
    
    ....
}

在spring.xml文件中添加配置使用复杂类型注入

<bean id="student4" class="com.zking.spring01.entity.Student">
    <property name="lst">
        <list>
            <value>zhangsan</value>
            <value>lisi</value>
            <value>wangwu</value>
        </list>
    </property>
    <property name="arr">
        <array>
            <value>xiaoming</value>
            <value>xiaoliu</value>
            <value>xiaoli</value>
        </array>
    </property>
    <property name="map">
        <map>
            <entry>
                <key>
                    <value>name</value>
                </key>
                <value>zhangsan</value>
            </entry>
            <entry>
                <key>
                    <value>sex</value>
                </key>
                <value>男</value>
            </entry>
            <entry>
                <key>
                    <value>address</value>
                </key>
                <ref bean="address"/>
            </entry>
        </map>
    </property>
    <property name="properties">
        <props>
            <prop key="aa">123</prop>
            <prop key="bb">456</prop>
        </props>
    </property>
</bean>

        3.8、日期类型注入

新增日期属性：

public class Student{
​
    private Date birthday;
    
    ....
    
    public Date getBirthday() { 
        return birthday; 
    } 
  
    public void setBirthday(Date birthday) { 
        this.birthday = birthday; 
    } 
}

利用SimpleDateFormat的构造方法注入：

<!-- 日期格式注入 -->
<bean id="dateFormat" class="java.text.SimpleDateFormat">
    <constructor-arg value="yyyy-MM-dd" />
</bean>
<bean id="student5" class="com.zking.spring01.entity.Student">
    <property name="birthday">
        <bean factory-bean="dateFormat" factory-method="parse">
            <constructor-arg value="1999-02-12" />
        </bean>
    </property>
</bean>

4、Spring跟web的集成配置

        

4.1.创建监听器

/**
 * Spring与Web项目集成
 * 
 * Application监听器
 * @author Administrator
 *
 */
public class SpringListener implements ServletContextListener {
    
    private String path="classpath:spring.xml";
 
    /**
     * 上下文初始化方法，只会初始化一次
     */
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("contextInitialized...");
        //获取ServletContext上下文中的application对象
        ServletContext application=sce.getServletContext();
        //获取web.xml中的spring配置文件路径
        String param = application.getInitParameter("contextConfigLocation");
        if(null!=param&&!"".equals(param))
            path=param;
        //创建Spring上下文对象
        ApplicationContext ac=new ClassPathXmlApplicationContext(path);
        //将创建的Spring上下文对象保存到ServletContext的Application中
        SpringWebUtils.setContext(application, ac);
    }
​
    /**
     * 上下文销毁方法
     */
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("contextDestroyed");
    }
}

创建SpringWebUtil工具类，将Spring上下文对象保存到Application作用域中。

public class SpringWebUtils {
    public SpringWebUtils() {}
    private static final String KEY="aaaa";
    public static void setContext(ServletContext application,
            ApplicationContext ac) {
        application.setAttribute(KEY, ac);
    }
    public static ApplicationContext getContext(ServletContext application) {
        return (ApplicationContext)application.getAttribute(KEY);
    }
}

        4.2、编写web.xml文件内容（创建监听器），配置spring.xml到上下文中(注：需要创建Web项目才会有web文件的存在，有关Idea基于Maven的Web项目创建，会在近期发布相关博客文章，记得持续关注本猿！！！！)

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="WebApp_ID" version="3.0">
  <display-name>Archetype Created Web Application</display-name>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:Spring.xml</param-value>
  </context-param>
  <listener>
    <listener-class>com.zking.listener.SpringListener</listener-class>
  </listener>
</web-app>

        4.3、测试

<%@page import="com.zking.spring01.util.SpringWebUtils"%>
<%@page import="javax.servlet.ServletContext" %>
<%@page import="org.springframework.context.ApplicationContext" %>
<%@page import="com.zking.spring01.entity.Student" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%
	ApplicationContext ac=SpringWebUtils.getContext(application);
	Student stu=(Student)ac.getBean("student4");
	System.out.println(stu.getLst());
%>
</body>
</html>