spring之IOC

最新推荐文章于 2024-05-24 00:06:57 发布

夺命关东煮

最新推荐文章于 2024-05-24 00:06:57 发布

阅读量89

点赞数

文章标签： spring java 后端

本文链接：https://blog.csdn.net/xyy_0517/article/details/121083577

版权

一，spring简介

1.什么是Spring？作用有什么？

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。

Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。
然而，Spring的用途不仅限于服务器端的开发。

从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
目的：解决企业应用开发的复杂性
功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能
范围：任何Java应用
简单来说，Spring是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架。

2.Spring全家桶

3.Spring是多数框架的中间层框架、万能胶

SSH框架（集成框架）=struts+spring（核心框架）+hibernate

4.组成（容器框架：把所有框架整合）：

JavaBean 项目中的一个个类

IOC和AOP

二、IOC（控制反转或依赖注入）

1.什么是IOC？
控制反转(IoC=Inversion of Control)

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

IOC还有一个另外的名字：“依赖注入 (DI=Dependency Injection)” ，即由容器动态的将某种依赖关系注入到组件之中

案例（解释IOC）：实现Spring的IOC（模拟开发场景）

①导入相关依赖（pom.xml）

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.xhy</groupId>
  <artifactId>SSH_spring</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>SSH_spring Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>
        <spring.version>5.0.1.RELEASE</spring.version>
        <javax.servlet.version>4.0.0</javax.servlet.version>
        <junit.version>4.12</junit.version>
    </properties>
  
  <dependencies>
        <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>
    </dependencies>
  <build>
    <finalName>SSH_spring</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>

原来是写一个接口类UserBiz（写上传功能）：

public interface UserBiz {
public void upload();

}

实现接口类UserBizImpl1：

/**
* 功能：上传
* @author zjjt
*
*/
public class UserBizImpl1 implements UserBiz{
@Override
public void upload() {
System.out.println("按要求开发功能");

}

}

分析：
假设做一个上传功能
现在提出整改要求：1，限定上传文件大小 2，限定上传文件类别

现在有几个版本的要求：
action1 不需要加限制 action2 需要加限制

假设你有开发一个游戏，原版本action1不需要加限制，当你开发出了一个新功能，需要更新版本action2，如果更新给游戏其他功能带来问题，我们需要要回到上一个版本，这是IOC的功能就体现出来了

优化：更具上面要求，实现类UserBizImpl2.java实现优化性能功能

public class UserBizImpl2 implements UserBiz{
@Override
public void upload() {
// TODO Auto-generated method stub
System.out.println("做条件判断，加限定，不符合要求的不给予上传");
System.out.println("按要求开发功能");

}

}

总结：1.更新版本需要改动原有代码 2.相关调用此方法的模块伴随着巨大风险

Spring版本：

①导入相关依赖（上面）

②配置文件（配置项目中所有JavaBean，目的在于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"
    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 name="userBiz1" class="com.xhy.ioc.biz.impl.UserBizImpl1"></bean>
<bean name="userBiz2" class="com.xhy.ioc.biz.impl.UserBizImpl2"></bean>
<bean name="personAction" class="com.xhy.ioc.web.PersonAction">
<property name="userBiz" ref="userBiz2"></property>
</bean>
<bean name="userAction" class="com.xyy.ioc.web.UserAction"></bean>
</beans>

③action：每个action类不需要调用类，只需实例化类并给类get、set方法

public class PersonAction {
    private UserBiz userBiz;
    

    public UserBiz getUserBiz() {
        return userBiz;
    }
    public void setUserBiz(UserBiz userBiz) {
        this.userBiz = userBiz;
    }
    public void upload() {
        userBiz.upload();
    }
    //新版本
    public static void main(String[] args) {
        PersonAction personAtion=new PersonAction();
        personAtion.upload();
    }
}

测试：

public class IocTest {
public static void main(String[] args) {
    //建模
    ApplicationContext applicationContest=new ClassPathXmlApplicationContext("/spring-context.xml");

PersonAction personAction = (PersonAction) applicationContest.getBean("personAction");
        personAction.upload();
}
}

如果版本切换，就不用去修改代码，直接修改配置文件

比如：<bean name="personAction" class="com.xhy.ioc.web.PersonAction">
<property name="userBiz" ref="userBiz1"></property>
</bean>

ioc操作： 将以前由程序员实例化对象/赋值的工作交给了spring处理

三、Spring的传参

怎么给JavaBean初始化赋值（传参怎么）？

1.set传参

2.构造传参

3.自动装配（基本不用）

1、set传参

定义一个实体类ParamAction ：

public class ParamAction {
    private int age;
    private String name;
    private List<String> hobby;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<String> getHobby() {
        return hobby;
    }
    public void setHobby(List<String> hobby) {
        this.hobby = hobby;
    }
    public void execute() {
        System.out.println(this.name);
        System.out.println(this.age);
        System.out.println(this.hobby);
    }
}

在spring-context.xml中进行配置

<bean name="ParamAction" class="com.xhy.ioc.web.ParamAction">
    <property name="name" value="xyy"></property>
    <property name="age" value="19"></property>
    <property name="hobby">
    <list>
    <value>吃饭</value>
    <value>睡觉</value>
    <value>打豆豆</value>
    </list>
    </property>
    </bean>

测试

public class IocTest {
public static void main(String[] args) {
    //建模
    ApplicationContext applicationContest=new ClassPathXmlApplicationContext("/spring-context.xml");
    ParamAction paramAction = (ParamAction) applicationContest.getBean("ParamAction");
            paramAction.execute();
}
}

2、构造传参

给实体类ParamAction 添加有参无参的构造方法：

public class ParamAction {
    private int age;
    private String name;
    private List<String> hobby;
    public ParamAction() {
        // TODO Auto-generated constructor stub
    }
    public ParamAction(int age, String name, List<String> hobby) {
        super();
        this.age = age;
        this.name = name;
        this.hobby = hobby;
    }

    public void execute() {
        System.out.println(this.name);
        System.out.println(this.age);
        System.out.println(this.hobby);
    }
}

在spring-context.xml中进行配置

<!-- 构造器传参 -->
    <constructor-arg name="name" value="小慧"></constructor-arg>
    <constructor-arg name="age" value="19"></constructor-arg>
    <constructor-arg name="hobby" >
    <list>
    <value>hhh</value>
    <value>睡觉jiao</value>
    <value>jiojio子</value>
    </list>
    </constructor-arg>

四、Spring与tomcat整合

功能：减少建模（建模很消耗性能），性能优化，减少服务器的压力

建立一个监听器：建模的过程直接放到监听器里面完成

public class SpringLoaderListener implements ServletContextListener{
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("监听器方法执行……");
        ApplicationContext ac=new ClassPathXmlApplicationContext("/spring-context.xml");
        sce.getServletContext().setAttribute("SpringContext", ac);
            }

}

在web.xml中进行配置：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <display-name>Archetype Created Web Application</display-name>
<listener>
  <listener-class> com.xhy.ioc.listener.SpringLoaderListener</listener-class>
 </listener>
</web-app>

在servlet中可以直接得到spring上下文，不需再次建模：

@WebServlet("/user")
public class UserServlet extends HttpServlet{
    
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ApplicationContext springContext = (ApplicationContext) req.getServletContext().getAttribute("SpringContext");
        ParamAction paramAction = (ParamAction) springContext.getBean("paramAction");
        paramAction.execute();
    }
}

监听只执行一次