Spring的定义

LJT_1314520

于 2023-03-20 15:08:08 发布

阅读量98

点赞数

分类专栏： spring 文章标签： intellij-idea Powered by 金山文档

本文链接：https://blog.csdn.net/LJT_1314520/article/details/129666353

版权

spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1. 什么是spring，它能够做什么?

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

Spring项目出发点：

目的：提供一种贯穿始终的解决方面，将各种专用框架整合成一个连贯的整体框架，简化企业级应用的开发（有点像粘合剂）

鼓励最佳实践：例如spring将“针对接口编程”的成本降到了最小

非侵入性：应用对象尽量避免依赖框架，IoC和AOP是避免依赖的关键技术

统一配置：好的框架应该让应用配置灵活且统一

易于测试：使单元测试尽可能简单

可扩展：

简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

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

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

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

3. AOP的关键概念

连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出.

目标(Target)：被通知(被代理)的对象

通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)

代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),请注意：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的

切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。(也将Pointcut理解成一个条件，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)

适配器(Advisor)：适配器=通知(Advice)+切入点(Pointcut)

4. 示例

4.1 创建工程

创建一个web工程，并转换为web3.1，详细步骤可参见“maven”课件

4.2 pom文件

<properties>
        <hibernate.version>5.2.12.Final</hibernate.version>
        <mysql.driver.version>5.1.44</mysql.driver.version>
        <spring.version>5.2.6.RELEASE</spring.version>
        <struts2.version>2.5.13</struts2.version>
        <slf4j.version>1.7.7</slf4j.version>
        <log4j.version>2.9.1</log4j.version>
        <disruptor.version>3.2.0</disruptor.version>
        <junit.version>4.12</junit.version>
        <servlet.version>4.0.1</servlet.version>
        <jstl.version>1.2</jstl.version>
        <standard.version>1.1.2</standard.version>
        <tomcat-jsp-api.version>8.5.20</tomcat-jsp-api.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- spring 相关 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</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-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.driver.version}</version>
        </dependency>
    
        <!--4. log配置：Log4j2 + Slf4j -->
        <!-- slf4j核心包 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${slf4j.version}</version>
            <scope>runtime</scope>
        </dependency>

        <!--用于与slf4j保持桥接 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>${log4j.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!--核心log4j2jar包 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j.version}</version>
        </dependency>

        <!--web工程需要包含log4j-web，非web工程不需要 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-web</artifactId>
            <version>${log4j.version}</version>
            <scope>runtime</scope>
        </dependency>
        <!--需要使用log4j2的AsyncLogger需要包含disruptor -->
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>${disruptor.version}</version>
        </dependency>

        <!--5. other -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--6. jstl -->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl.version}</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>${standard.version}</version>
        </dependency>

        <!-- 7. jsp自定义标签依赖 (必须与tomcat的版本一致) -->
        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-jsp-api</artifactId>
            <version>${tomcat-jsp-api.version}</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

注：该依赖配置不仅包含了spring，同时也包含了hibernate，struts，mysql驱动等。

4.3 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" xmlns:tx="http://www.springframework.org/schema/tx"
    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
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">


    
</beans>

4.4 示例代码

4.4.1 示例1

1） Student

public class Student {
    
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Demo [name=" + name + "]";
    }

}

2） spring.xml 配置文件

<bean id="demo" class="org.lisen.springdemo.model.Demo">
        <property name="name">
            <value>张三</value>
        </property>
    </bean>

配置文件说明：

id：在容器中查找Bean的id(唯一、且不能以/开头)

class：bean的完整类名

name：在容器中查找Bean的名字(唯一、允许以/开头、允许多个值，多个值之间用逗号或空格隔开)

scope:(singleton|prototype)默认是singleton
singleton: 单例模式, 在每个Spring IoC容器中一个bean定义对应一个对象实例
prototype：原型模式/多例模式, 一个bean定义对应多个对象实例

parent：指定一个父bean(必须要有继承关系才行)

abstract: 将一个bean定义成抽象bean(抽象bean是不能实例化的),抽象类一定要定义成抽象bean,非抽象类也可以定义成抽象bean

注：在这里配置的name属性为简单的String属性，可以直接使用value进行配置。另外可以直接使用value设置的如下：
8基础数据+String+3个sql
java.util.Date
java.sql.Date
java.sql.Time
java.sql.Timestamp

3）通过Spring的ApplicationContext获取Bean

public class SpringDemo {
    
    public static void main(String[] args) {
        ApplicationContext cxt = new ClassPathXmlApplicationContext("spring.xml");
        Student demo = (Student)cxt.getBean("demo");
        System.out.println(demo);
    }

}

4.4.2 示例2 （abstract，parent示例）

1） Person

public class Student extends Person {
    
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Demo [name=" + name + "]";
    }

}

2） Student

public class Student extends Person {
    
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Demo [name=" + name + "]";
    }

}

3）配置文件

<bean id="student" class="org.lisen.springdemo.model.Student" parent="person">
        <property name="name">
            <value>张三</value>
        </property>
    </bean>
    
    <bean id="person" class="org.lisen.springdemo.model.Person" abstract="true">
        <property name="phone">
            <value>139751878778</value>
        </property>
    </bean>

4）通过Spring的ApplicationContext获取Bean

public class SpringDemo {
    
    public static void main(String[] args) {
        ApplicationContext cxt = new ClassPathXmlApplicationContext("spring.xml");
        Student student = (Student)cxt.getBean("student");
        System.out.println(student.getName());
        System.out.println(student.getPhone());
    }

}

4.4.3 使用有参数构造方法创建javaBean

constructor-arg

1） Worker

public class Worker extends Person {

    private String workName;
    
    public Worker(String workName) {
        this.workName = workName;
    }

    public String getWorkName() {
        return workName;
    }

    public void setWorkName(String workName) {
        this.workName = workName;
    }
    
}

配置文件

<bean id="worker" class="org.lisen.springdemo.model.Worker" parent="person">
        <constructor-arg name="workName">
            <value>王小</value>
        </constructor-arg>
        <!-- 第二种方式
        <constructor-arg index="0">
            <value>王小</value>
        </constructor-arg>
         -->
    </bean>

3）通过Spring的ApplicationContext获取Bean

public class SpringDemo {
    
    public static void main(String[] args) {
        ApplicationContext cxt = new ClassPathXmlApplicationContext("spring.xml");
        Student student = (Student)cxt.getBean("student");
        System.out.println(student.getName());
        System.out.println(student.getPhone());
        
        //构造函数注入
        Worker worker = (Worker)cxt.getBean("worker");
        System.out.println(worker.getWorkName());
    }

}

4.4.4 init-method：指定bean的初始化方法

修改上面的Student类，加入一个init方法，注意该方法不能有参数

public class Student extends Person {
    
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Demo [name=" + name + "]";
    }
    
    //init方法，不能有参数
    public void init() {
        System.out.println("Student init ....");
    }

}

2）修改Student类对应的配置文件

<bean id="student" class="org.lisen.springdemo.model.Student" parent="person" init-method="init">
        <property name="name">
            <value>张三</value>
        </property>
    </bean>

3）运行原来的测试用例，会发生后台打印“Student init ....“，表示init-method正常调用。

4.4.5 复杂属性的配置

1） JavaBean属性注入

<bean id="student" class="org.lisen.springdemo.model.Student" parent="person" init-method="init">
        <property name="name">
            <value>张三</value>
        </property>
        <property name="addr" ref="addr"/>
    </bean>
    
    <bean id="addr" class="org.lisen.springdemo.model.Addr">
        <property name="city">
            <value>长沙</value>
        </property>
    </bean>

java部分代码比较简单，请根据配置文件自行完成。

2）List或数组

声明属性

 private int[] arr;
 private List list;

配置文件

 <property name="list">
            <list>
                <value>123</value>
                <value>456</value>
                <value>789</value>
                <value>asd</value>
            </list>
        </property>

private Map map;

配置文件

  <property name="prop">
            <props>
                <prop key="dd">qwer</prop>
                <prop key="ee">tyu</prop>
                <prop key="ff">iop</prop>
            </props>
        </property>

5. 多配置文件

系统一般会被分成多个模块，可以为每个模块配置一个配置文件，便于管理，在版本控制软件中也可以减少冲突

spring-a.xml 假设为a模块的配置文件

<?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" xmlns:tx="http://www.springframework.org/schema/tx"
    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
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
    
    <bean id="student" class="org.lisen.springdemo.model.Student" parent="person" init-method="init">
        <property name="name">
            <value>张三</value>
        </property>
        <property name="addr" ref="addr"/>
    </bean>
    
    <bean id="addr" class="org.lisen.springdemo.model.Addr">
        <property name="city">
            <value>长沙</value>
        </property>
    </bean>
    
    <bean id="person" class="org.lisen.springdemo.model.Person" abstract="true">
        <property name="phone">
            <value>139751878778</value>
        </property>
    </bean>
    
    <bean id="worker" class="org.lisen.springdemo.model.Worker" parent="person">
        <constructor-arg name="workName">
            <value>王小</value>
        </constructor-arg>
        <!-- 第二种方式
        <constructor-arg index="0">
            <value>王小</value>
        </constructor-arg>
         -->
    </bean>
    
</beans>

spring.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" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    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
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
    
    <import resource="spring-a.xml"/>
    
</beans>

6. 与web集成

6.1 集成配置

在web.xml中加入如下配置：

 <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml</param-value>
    </context-param>

     <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

6.2 获取配置的Bean

/**
 * 用于简化Bean的获取.
 * 
 * ApplicationContextAware接口：
 * 实现了这个接口的bean，当spring容器初始化的时候，会自动的将ApplicationContext注入进来
 * 
 * @author Administrator
 */
public final class SpringBeanUtil implements ApplicationContextAware {
    
    private SpringBeanUtil() {
    }
    
    private static ApplicationContext cxt;

    @Override
    public void setApplicationContext(ApplicationContext appContext) throws BeansException {
        cxt = appContext;
    }
    
    
    /**
     * 根据Bean的id来获取Bean对象
     * @param id 配置文件中的bean的id属性
     * @return Object
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String id) {
        return (T)cxt.getBean(id);
    }
    
}

配置文件

 <bean class="org.lisen.springdemo.util.SpringBeanUtil"/>

LJT_1314520

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring的定义

然而，Spring的用途不仅限于服务器端的开发。控制反转(IoC=Inversion of Control)IoC，用白话来讲，就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),请注意：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的。
复制链接

扫一扫