一、简介

1、什么是spring？

Spring是一个开源的轻量级Java应用开发框架，它提供了一种简单、高效、灵活的方式来构建企业级应用程序。Spring框架的核心特点是依赖注入（Dependency Injection）和面向切面编程（Aspect-Oriented Programming），它通过一组模块化的组件提供全面的支持，使开发人员能够快速搭建可扩展、可维护的应用。

2、目的

学习Spring的目的可以总结为以下几点：

1. 简化开发：Spring提供了一系列的工具和抽象，简化了企业级应用开发过程。它通过依赖注入来解决对象间的依赖关系，使得代码更加灵活、可测试和可维护。
2. 高效开发：Spring框架提供了诸多模块，如Spring MVC、Spring Boot等，可以快速构建Web应用和微服务。它提供了一种约定优于配置的开发方式，提高了开发效率。
3. 提高可扩展性：Spring框架基于接口和模块化设计，能够方便地集成其他开源框架和库。它的松耦合特性使得应用程序更易于扩展和维护。
4. 丰富的功能：Spring拥有丰富的功能和特性，包括事务管理、安全性、缓存、消息队列、调度等。它为开发人员提供了一系列解决方案，使得应用程序开发更加便捷。

3、功能及使用范围

Spring的功能范围非常广泛，包括但不限于以下方面：

1. 依赖注入和控制反转：通过依赖注入，Spring容器能够将对象之间的依赖关系管理起来，使得对象的创建和使用解耦，提高代码的灵活性和可测试性。
2. 面向切面编程：Spring提供了面向切面编程（AOP）的支持，可以将与核心业务逻辑无关的功能（如事务管理、日志记录等）进行横切，提高了代码的重用性和可维护性。
3. Web开发支持：Spring提供了Spring MVC模块，用于开发Web应用程序。它能够处理HTTP请求和响应，进行URL路由、数据绑定、表单验证、视图解析等操作，简化了Web开发过程。
4. 数据访问支持：Spring框架提供了对各种数据访问技术的支持，包括JDBC、ORM（如Hibernate、MyBatis）、JPA等。它通过抽象出一套统一的数据访问接口，使得数据库访问更加方便和可替换。
5. 安全性支持：Spring提供了一套强大的安全性框架，可以进行认证和授权管理。它支持各种身份验证方式，如基于表单的认证、基于角色的访问控制等，保护应用程序的安全性。

总之，Spring框架是Java开发领域最流行的框架之一，它提供了丰富的功能和特性，帮助开发人员构建可靠、高效的企业级应用程序。

一句话概括，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

二、spring IOC

1、ioc的理解

IoC（Inversion of Control，控制反转）是Spring框架的核心概念之一，也是实现依赖注入的基础。它通过解耦对象之间的依赖关系，使得对象的创建和管理由框架来负责，而不是由开发人员手动管理。

在传统的程序设计中，对象之间的依赖关系通常由开发人员在代码中进行硬编码，对象直接通过关键字（如new）来创建和管理。这种方式存在一些问题，如对象之间的耦合度高、可测试性差、扩展性差等。

而IoC则是一种思想上的转变，它将对象的创建和管理权利交给了框架。具体来说，IoC的核心思想是：通过配置或注解，告诉框架需要创建哪些对象，以及对象之间的依赖关系。然后，框架在应用程序运行时根据配置信息动态地创建和组装对象。

Spring通过IoC容器来实现控制反转。IoC容器是一个用于管理对象的容器，它负责创建、组装、初始化和销毁对象。开发人员只需要配置对象的创建和依赖关系，然后通过容器来获取需要的对象即可。

使用Spring的IoC容器，开发人员可以达到以下几个目的：

1. 解耦对象之间的依赖关系：通过IoC容器，开发人员只需要关注对象的功能实现，而不需要关心对象是如何创建和组装的。对象之间的依赖关系由容器负责管理，降低了对象之间的耦合度。
2. 提高代码的可测试性：由于对象的创建和组装由容器来完成，开发人员可以很容易地对对象进行替换或模拟，从而实现单元测试和集成测试。
3. 增强代码的可扩展性：当需要添加新的功能或模块时，只需要配置新的对象和依赖关系，而不需要修改现有的代码。通过配置方式，可以方便地在不影响现有代码的情况下进行扩展。
4. 提高代码的灵活性：IoC容器使得对象的创建完全可配置化，可以在运行时根据需要创建不同的实例。同时，框架提供了生命周期管理和依赖解析等功能，使得对象的管理更加便捷。

总而言之，IoC是Spring框架的核心特性之一，它通过控制反转的思想，将对象的创建和依赖关系的管理交给了框架，减少了对象之间的耦合度，提高了代码的可测试性和可扩展性。

2、分析实现

首先创建好我们的maven项目

 设置我们的pom.xml

    <dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency><!-- 2、导入spring依赖 --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>${spring.version}</version></dependency><!-- 5.1、junit --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>${junit.version}</version><scope>test</scope></dependency><!-- 5.2、servlet --><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>${javax.servlet.version}</version><scope>provided</scope></dependency>

新建

我们用原来的方式写一下

1. 编写一个接口

   public interface UserService {public void updUser();
   }

2. 再编写一个实现类

   public class UserServiceImpl1 implements UserService {public void updUser() {System.out.println("修改SQL用户数据");
   }

   我们原来的方式是这样写的

3. 现在我们添加一个实现类

   public class UserServiceImpl2 implements UserService {public void updUser() {System.out.println("修改SQL用户数据");//修改用户姓名System.out.println("修改用户姓名");}
   }

4. 当我们测试调方法的时候只需要改动后面的实现类

5. 手动实例化的弊端：
   1、一旦依赖的接口实现需要大批量改动，迭代，维护成本高
    2、当接口的实现类不统一，维护成本更高

我们怎么解决这个问题呢？

3、编写bean

首先我们要在maven项目里面的resources文件里面建立一个基于spring的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>

 我们在web文件里面建立两个Class类

public class UserAction {private UserService us;public UserService getUs() {return us;}public void setUs(UserService us) {this.us = us;}public String updUser() {us.updUser();return "list";}}

public class GoodsAction {private UserService us;public UserService getUs() {return us;}public void setUs(UserService us) {this.us = us;}public String updUser() {us.updUser();return "list";}}

编写一个测试类

public class demo1 {public static void main(String[] args) {
//        加载spring核心配置文件（建模），获取spring的上下文对象，上下文对象中可以获取任何JavaBean对象ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");UserAction userAction = (UserAction) context.getBean("userAction");userAction.updUser();GoodsAction goodsAction = (GoodsAction) context.getBean("goodsAction");goodsAction.updUser();}
}

在我们的新建的这个spring-context.xml文件里面添加<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"><!--凡是在spring核心配置文件spring-context.xml中配置，那么该类JavaBean就交给了spring容器管理--><bean class="com.tgq.ioc.web.UserAction" id="userAction"><property name="us" ref="userService1"/></bean><bean class="com.tgq.ioc.web.GoodsAction" id="goodsAction"><property name="us" ref="userService2"/></bean><bean class="com.tgq.ioc.service.impl.UserServiceImpl1" id="userService1"/><bean class="com.tgq.ioc.service.impl.UserServiceImpl2" id="userService2"/>
</beans>

 

三、spring IOC的注入方式

spring的ioc有哪些注入方式呢？

1. set方法属性注入
2. 构造注入
3. 接口注入/自动装配

1、set方法属性注入

在我们前面的GoodsAction新添几个属性和get、set方法，一个输出打印的方法toPrint()

public class GoodsAction {private UserService us;private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public List<String> getPeoples() {return peoples;}public void setPeoples(List<String> peoples) {this.peoples = peoples;}private List<String> peoples;public UserService getUs() {return us;}public void setUs(UserService us) {this.us = us;}public String updUser() {us.updUser();return "list";}public void toPrint() {System.out.println(this.name);System.out.println(this.age);System.out.println(this.peoples);}}

在print-context.xml里面设置值，使用set方法属性注入用property

    <bean class="com.tgq.ioc.web.GoodsAction" id="goodsAction"><property name="us" ref="userService2"></property><property name="name" value="旺财"/><property name="age" value="20"/><property name="peoples"><list><value>留守儿童</value><value>情侣</value><value>留守老人</value></list></property></bean>

在测试类里面调用

goodsAction.toPrint();

 

2、构造注入

在我们的User Action里面添加属性及有参无参的构造方法，一个输出打印的方法toPrint()

public class UserAction {private UserService us;private String name;private int age;private List<String> hobby;public UserAction() {}public UserAction(String name, int age, List<String> hobby) {this.name = name;this.age = age;this.hobby = hobby;}public UserService getUs() {return us;}public void setUs(UserService us) {this.us = us;}public String updUser() {us.updUser();return "list";}public void toPrint() {System.out.println(this.name);System.out.println(this.age);System.out.println(this.hobby);}
}

在print-context.xml里面设置值，使用构造输入需要用constructor-arg标签

    <bean class="com.tgq.ioc.web.UserAction" id="userAction"><property name="us" ref="userService1"/><constructor-arg name="name" value="l"/><constructor-arg name="age" value="18"/><constructor-arg name="hobby"><list><value>唱</value><value>跳</value><value>rap</value></list></constructor-arg></bean>

继续在测试类里面调用toPrint方法

 

 

3、自动装配

自动装配中byName和byType的区别：

byName：在配置好的文件中变量名不更改就不会报错。按照属性的名称进行自动装配。

1. 当一个bean的属性名称与其他bean的id匹配时，Spring容器会自动将该bean注入到对应的属性中。
2. 如果找不到匹配的bean，则会抛出异常。
3. 在XML配置中，可以使用autowire="byName"或@Autowired注解实现byName自动装配。

byType：会在整个spring中寻找JavaBean，按照属性的类型进行自动装配。

1. 当一个bean的属性的类型与其他bean的class匹配时，Spring容器会自动将该bean注入到对应的属性中。
2. 如果有多个匹配的bean，则会抛出异常，需要进行更具体的限定或使用@Qualifier注解来解决。
3. 在XML配置中，可以使用autowire="byType"或@Autowired注解实现byType自动装配。

四、spring与tomcat的整合/spring与web容器的整合

我们的xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"default-autowire="byName"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核心配置文件spring-context.xml中配置，那么该类JavaBean就交给了spring容器管理--><bean class="com.tgq.ioc.web.UserAction" id="userAction"><property name="us" ref="userService1"/></bean><bean class="com.tgq.ioc.web.GoodsAction" id="goodsAction"><property name="us" ref="userService2"/></bean><bean class="com.tgq.ioc.service.impl.UserServiceImpl1" id="userService1"/><bean class="com.tgq.ioc.service.impl.UserServiceImpl2" id="userService2"/>
</beans>

编写一个过滤器

@WebListener
public class sprintListener implements ServletContextListener {@Overridepublic void contextInitialized(ServletContextEvent sce) {System.out.println("初始化");//spring的上下文ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
//tomcat上下文ServletContext servletContext = sce.getServletContext();servletContext.setAttribute("sprintContext", context);}
}

编写servlet类调用它

@WebServlet("userlist")
public class Userservlet extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {this.doPost(req, resp);}@Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {//获取到sprint的上下文对象ClassPathXmlApplicationContext Context = (ClassPathXmlApplicationContext) req.getServletContext().getAttribute("sprintContext");UserService bean = (UserService) Context.getBean("userService1");System.out.println(bean);bean.updUser();}
}

启动服务器就完成了整合