ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

Spring 原理及项目实践 Demo

2020-02-20 17:09:21  阅读:17  来源: 互联网

标签:容器 配置文件 Spring 实践 Bean Demo org 属性



目录

1、Spring 概述

根据功能的不同, 可以将一个系统中的代码分为主业务逻辑系统级业务逻辑两类。

  • 主业务逻辑:联系紧密,有具体的专业业务应用场景,复用性相对较低;
  • 系统级业务:功能相对独立,主要为主业务提供系统级服务,如日志、安全、事务等,复用性较高。

2、Spring 特点

2.1 非侵入式

Spring 框架的 API 不会出现在业务逻辑( POJO )中。所以业务逻辑可以从 Spring 框架快速移植到其他框架。

2.2 容器

Spring 作为容器可以对对象进行管理(创建和销毁),并且通过配置文件定义对象以及对象之间关系。

2.3 IoC

控制反转(Inversion of Control),由 Spring 容器创建对象实例,并且注入调用者。Spring 容器在对象初始化时就主动将对象的依赖传递给该对象。

实现方式:依赖查找和依赖注入( Spring 采用这种方式)

  • 依赖查找:容器提供回调接口和上下文环境给组件,程序代码提供具体查找方式。
  • 依赖注入:程序运行过程中如果需要调用其他对象,则直接由容器来创建该对象然后传递给程序。

2.4 AOP

面向切面编程(Aspect Orient Programming)是一种编程思想。将日志、安全、事务管理等服务作为一个 “切面” 动态 “织入” 到业务逻辑中,以达到服用的目的。

3、Spring 项目实践

3.1 创建 Maven 项目,导入 Spring 及相关依赖

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>aoing.com</groupId>
<artifactId>spring_demo</artifactId>
<version>1.0-SNAPSHOT</version>


<dependencies>

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

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

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

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

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

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.25</version>
    </dependency>

    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-slf4j-impl</artifactId>
        <version>2.12.1</version>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.12.1</version>
    </dependency>

    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>2.12.1</version>
    </dependency>

</dependencies>

3.2 创建实体类

User.java

package com.aoing.bean;

/**
 * @author Aoing
 * @Description
 * @create 2020-02-19 21:39:58
 * @since v1.0.0
 */
public class User {
    private Integer userId;
    private String  name;
    private String  password;



    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

3.3 创建 Spring 配置文件

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
< beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
							http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
							http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
							http://www.springframework.org/schema/context
							http://www.springframework.org/schema/tx ">

    <!--注册user类-->
    <bean name="user" class="com.aoing.bean.User"></bean>	
    
< /beans>

3.4 添加 log4j 配置文件

log4j.xml

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

< !-- status属性用于设置 Log4j2 自身运行的日志显示级别 -->
< Configuration status="OFF">

<!-- 只要在<appenders/>中定义了<File/>、<RollingFile/>等,且在其中指定了日志存放的目录,那么这些目录就会自动创建。无论在<loggers/>的<root/>中是否声明使用它们。 -->
<Appenders>
    <!-- 标签的 target 属性用于设置输出的目标形式,其值一般为:SYSTEM_OUT 或 SYSTEM_ERR -->
    <Console name="Console" target="SYSTEM_OUT">
        <PatternLayout pattern="[%-5p][%d{yyyy-MM-dd HH:mm:ss.SSS}] [%c %L] %m%n"/>
    </Console>

    <!-- 标签的 fileName 属性用于设置文件的文件保存路径及文件名,将其存放在当前项目的根目录下的 log 子目录的 test.log 中。 -->
    <!-- append 属性用于设置是否以追加方式将日志写入指定文件。 -->
    <File name="LogFile" fileName="Log/test.log" append="true">
        <PatternLayout pattern="[%-5p][%d{yyyy-MM-dd HH:mm:ss}] [%c %L] %m%n"/>
    </File>

    <!-- fileName 指定存放目录及第一个日志文件名。filePattern 指定新创建的日志文件的文件名。 -->
    <RollingFile name="RollingFile" fileName="Logs/Log4j2.Log" filePattern="Logs/$${date:yyyy-MM}/Log4j2Test-%d{MM-dd-yyyy}-%i.log.gz">
        <PatternLayout charset="UTF-8" pattern="[%-5p][%d{yyyy-MM-dd HH:mm:ss}] [%c %L] %m%n"/>
        <!-- SizeBasedTriggeringPolicy子标签用于指定每一个日志文件最大文件大小。当达到这个指定值后,会自动再新建一个日志文件。 -->
        <SizeBasedTriggeringPolicy size="1KB"/>
    </RollingFile>
</Appenders>

<Loggers>
    <Logger name="*" level="trace" additivity="false">
        <AppenderRef ref="Console"/>
    </Logger>
    <Root level="info">
        <AppenderRef ref="Console"/>
    </Root>
</Loggers>

3.5 测试

MyTest.java

import com.aoing.bean.User;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author Aoing
 * @Description
 * @create 2020-02-19 22:10:59
 * @since v1.0.0
 */
public class MyTest {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyTest.class);

    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User) applicationContext.getBean("user");
        LOGGER.info(user.toString());
    }
}

4、两种接口容器

4.1 ApplicationContext 接口容器

4.1.1 配置文件在类路径下

在这里插入图片描述

4.1.2 配置文件在本地目录中

在这里插入图片描述

4.1.3 配置文件在项目根路径下

注意:如果使用 IDEA,则项目根目录指的是 project 目录而非 Modules 的目录。
在这里插入图片描述

4.2 BeanFactory 接口容器

在这里插入图片描述

4.3 两个接口区别

这两个容器对象却不是同一个对象,即不是同一个容器:它们对于容器内对象的装配(创建)时机是不同的。

  • ApplicationContext 容器中对象的装配时机:ApplicationContext 容器,会在容器对象初始化时, 将其中的所有对象一次性全部装配好。以后代码中若要使用到这些对象, 只需从内存中直接获取即可。 执行效率较高。 但占用内存。
  • BeanFactory 容器中对象的装配时机:BeanFactory 容器,对容器中对象的装配与加载采用延迟加载策略,即在第一次调用 getBean()时,才真正装配该对象。

5、Bean 的装配

5.1 使用 Spring 的动态工厂 Bean

在这里插入图片描述

5.2 静态工厂 Bean

在这里插入图片描述
在这里插入图片描述

5.3 容器中 Bean 的作用域

  • singleton:单态模式,整个 Spring 容器只有一个实例。
  • prototype:原型模式,每次使用 getBean 方法获取的都是一个新实例。
  • request:对于每次 HTTP 请求,都会产生一个不同的 bean 实例。
  • session:对于每个不同的 HTTP session,都会产生一个不同的 bean 实例。
  • global session:每个全局的 HTTP session 对应一个 Bean 实例。典型情况下,仅在使用
    portlet 集群时有效, 多个 Web 应用共享一个 session。 一般应用中, global-session 与session 是等同的。

注意:

  1. 对于 scope 的值 request、 session 与 global session, 只有在 Web 应用中使用 Spring 时,该作用域才有效。
  2. 对于 scope 为 singleton 的单例模式,该 Bean 是在容器被创建时即被装配好了。
  3. 对于 scope 为 prototype 的原型模式,Bean 实例是在代码中使用该 Bean 实例时才进行
    装配的。

在这里插入图片描述

5.4 定制 Bean 的生命始末

在这里插入图片描述
两个方法在对象类中实现

  • init-method:指定初始化方法的方法名
  • destroy-method:指定销毁方法的方法名

注意:若要看到 Bean 的 destroy-method 的执行结果,需要满足两个条件:

  1. Bean 为 singleton,即单例
  2. 要确保容器关闭。接口 ApplicationContext 没有 close()方法,但其实现类有。所以,可
    以将 ApplicationContext 强转为其实现类对象,或直接创建的就是实现类对象。
    在这里插入图片描述

5.5 Bean 的生命周期

  1. 调用无参构造器,创建实例对象
  2. 调用带参 setter,为属性注入值
  3. 若 Bean 实现了 BeanNameAware 接口,会执行接口方法 setBeanNames(String beanId),是 Bean 获取其在容器中 id 名称
  4. 若 Bean 实现了 BeanFactoryAware 接口,执行接口方法 setBeanFactory(BeanFactory factory),使 Bean 类可以获取 BeanFactory 对象
  5. 若定义并注册了 Bean 后处理器 BeanPostProcessor , 则执行接口方法 postProcessBeforeInilization()
  6. 若 Bean 实现了 InitializationBean 接口,则执行接口方法 afterPropertiesSet() 。该方法在 Bean 的所有属性的 set 方法执行完毕后执行, 是 Bean 初始结束的标志,即 Bean 实例化结束。
  7. 若设置了 init-method 方法,则执行
  8. 若定义并注册了 Bean 后处理器 BeanPostProcessor ,则会执行接口方法 postProcessorAfterInitialization()
  9. 执行业务方法
  10. 若 Bean 实现了 DisposableBean 接口,则执行接口方法 destroy()
  11. 若设置了 destroy-method 方法,则执行

5.6 标签的 id 属性与 name 属性

  • id 的命名需要满足 XML 对 ID 属性命名规范:必须以字母开头,可以包含字母、数字、
    下划线、连字符、句话、冒号。
  • name 属性值则可以包含各种字符。

6、基于 XML 的注入

注入: Spring 容器对 Bean 实例的属性进行初始化。

6.1 注入分类

  1. 设值注入
  2. 构造注入

6.1.1 设值注入

通过 setter 方法传入被调用者的实例,对象类中需要有 setter 方法。在配置文件中进行 property 属性初始化配置。

在这里插入图片描述
当 某一属性的值为另一个 bean 的实例,可通过 ref 指定引用关系。
在这里插入图片描述

6.1.2 构造注入

在调用者的构造器中对被调用者进行实例化。
在这里插入图片描述
在这里插入图片描述

6.2 集合属性注入

6.2.1 数组

在这里插入图片描述

6.2.2 List

在这里插入图片描述

6.2.3 Set

在这里插入图片描述

6.2.4 Map

在这里插入图片描述

6.2.5 Properties

在这里插入图片描述

6.3 为应用指定多个 Spring 配置文件

6.3.1 平等关系的配置文件

并将所有配置文件的路径定义为一个String 数组,将其作为容器初始化参数出现。
在这里插入图片描述

6.3.2 包含关系的 配置文件

总配置文件将各其它子文件通过< import/>引入。
在这里插入图片描述
在这里插入图片描述
也可使用通配符*。但,此时要求父配置文件名不能满足所能匹配的格式,否则将出现循环递归包含。就本例而言,==父配置文件不能匹配 spring-.xml 的格式==,即不能起名为spring-total.xml。

在这里插入图片描述
在这里插入图片描述

7、基于注解的 DI

对于 DI 使用注解, 将不再需要在 Spring 配置文件中声明 Bean 实例。

7.1 因为基于注解的 DI 需要 AOP 编程。

< dependency>
        < groupId>org.springframework< /groupId>
        < artifactId>spring-aop< /artifactId>
        < version>4.2.1.RELEASE< /version>
< /dependency>

7.2 需要更换配置文件头,即添加相应的约束。

	<?xml version="1.0" encoding="UTF-8"?>
	< !--beans中添加了许多约束,即像url一样的代码,其作用就是约束该.xml文件中可以使用哪些标签-->
	< beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	       xmlns="http://www.springframework.org/schema/beans"
	       xmlns:context="http://www.springframework.org/schema/context"
	       xmlns:aop="http://www.springframework.org/schema/aop"
	       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
								http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
								http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
								http://www.springframework.org/schema/context
								http://www.springframework.org/schema/tx ">

7.3 需要在 Spring 配置文件中配置组件扫描器,用于在指定的基本包中扫描注解。

在这里插入图片描述

7.4 在对象类上使用注解 @Component

需要在类上使用注解 @Component,该注解的 value 属性用于指定该 bean 的 id 值。
在这里插入图片描述

7.5 Bean 的作用域 @Scope

需要在类上使用注解@Scope,其 value 属性用于指定作用域。默认为 singleton。
在这里插入图片描述

7.6 基本类型属性注入 @Value

需要在属性上使用注解@Value,该注解的 value 属性用于指定要注入的值。使用该注解完成属性注入时,类中无需 setter。当然,若属性有 setter,则也可将其加到 setter 上。

在这里插入图片描述

7.7 按类型注入 域属性 @Autowired

需要在域属性上使用注解@Autowired,该注解默认使用按类型自动装配 Bean 的方式。使用该注解完成属性注入时,类中无需 setter。当然,若属性有 setter,则也可将其加到 setter 上。
在这里插入图片描述

7.8 按名称注入 域属性 @Autowired 与@Qualifier

需要在域属性上联合使用注解@Autowired 与@Qualifier。@Qualifier 的 value 属性用于指定要匹配的 Bean 的 id 值。同样类中无需 setter,也可加到 setter 上。@Autowired 还有一个属性 required, 默认值为 true, 表示当匹配失败后, 会终止程序运行。若将其值设置为 false,则匹配失败,将被忽略,未匹配的属性值为 null。
在这里插入图片描述

7.9 域属性注解 @Resource

7.9.1 按类型注入域属性

@Resource 注解若不带任何参数,则会按照类型进行 Bean 的匹配注入。

7.9.2 按名称注入域属性

@Resource 注解指定其 name 属性,则 name 的值即为按照名称进行匹配的 Bean 的 id。
在这里插入图片描述

7.10 Bean 的生命始末 @PostConstruct 与@PreDestroy

在方法上使用@PostConstruct, 与原来的 init-method 等效。 在方法上使用@PreDestroy,
与 destroy-method 等效。

8、使用 JUnit4 测试 Spring

  1. 引入依赖

     < dependency>
             < groupId>org.springframework</groupId>
             < artifactId>spring-test</artifactId>
             < version>4.2.1.RELEASE</version>
     < /dependency>
    
  2. 使用注解

     @RunWith(SpringJUnit4ClassRunner.class):用于指定运行环境  
     @ContextConfiguration(locations=“”):用于指定配置文件位置
    

在这里插入图片描述
在这里插入图片描述

9、注解与 XML 共同使用

  • 注解的好处是,配置方便,直观。但其弊端也显而易见:以硬编码的方式写入到了 Java
    代码中,其修改是需要重新编译代码的。
  • XML 配置方式的最大好处是, 对其所做修改, 无需编译代码只需重启服务器即可将新的配置加载。

若注解与 XML 同用,XML 的优先级要高于注解。这样做的好处是,需要对某个 Bean 做
修改,只需修改配置文件即可。当然,此时,Bean 类要有 setter 或构造器。

10、Spring 与 AOP

10.1 AOP

AOP(Aspect Orient Programming) ,面向切面编程,是面向对象编程 OOP 的一种补充。就是将交叉业务逻辑封装成切面,利用 AOP 容器的功能将切面织入主业务逻辑中。所谓交叉业务逻辑是指,通用的、与主业务逻辑无关的代码,如安全检查、事务、日志等。

在这里插入图片描述
MyInvocationHandler类中的invoke()方法完成的工作,就可以称为织入。

  • 面向对象编程是从静态角度考虑程序的结构
  • 面向切面编程是从动态角度考虑程序运行过程。

10.1.1 AOP 底层

采用动态代理模式实现的,采用了两种代理: JDK 的动态代理, 与 CGLIB 的动态代理。

10.1.2 AOP 好处

利用 AOP 可以对业务逻辑的各个部分进行隔离, 从而使得业务逻辑各部分之间的耦合度降低, 提高程序的可重用性,同时提高了开发的效率。

10.2 Advice 通知

  • 前置通知:在目标方法执行之前执行
  • 后置通知:在目标方法执行之后执行
  • 环绕通知:在目标方法执行之前与之后均执行
  • 异常处理通知:在目标方法执行过程中,若发生指定异常,则执行通知中的方法

10.2.1 动态代理

若不存在接口,则 ProxyFactoryBean 会自动采用 CGLIB 方式生成动态代理。
在这里插入图片描述

若存在接口,但又需要使用 CGLIB 生成代理对象,此时,只需要在配置文件中增加一个proxyTargetClass 属性设置,用于指定强制使用 CGLIB 代理机制。
在这里插入图片描述

或者指定 optimize(优化)的值为 true,强制使用 CGLIB 代理机制。

在这里插入图片描述

10.3 顾问 Advisor

顾问(Advisor)是 Spring 提供的另一种切面。其可以完成更为复杂的切面织入功能。
PointcutAdvisor 是顾问的一种,可以指定具体的切入点。顾问将通知进行了包装,会根据不
同的通知类型,在不同的时间点,将切面织入到不同的切入点。

PointcutAdvisor 接口有两个较为常用的实现类:

  • NameMatchMethodPointcutAdvisor 名称匹配方法切入点顾问
  • RegexpMethodPointcutAdvisor 正则表达式匹配方法切入点顾问

10.3.1 名称匹配 方法切入点顾问

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

10.3.2 正则表达式 方法 切入点顾问

注意,与正则表达式进行匹配的对象是接口中的方法名,而非目标类(接口的实现类)的方法名。
在这里插入图片描述
在这里插入图片描述

10.4 自动代理生成器

10.5 AspectJ 对 AOP 的实现

10.5.1 AspectJ 简介

AspectJ 是一个面向切面的框架,是对 AOP 的一种实现,AOP 是一种编程思想。

10.5.2 AspectJ 的通知类型

  1. 前置通知
  2. 后置通知
  3. 环绕通知
  4. 异常通知
  5. 最终通知:无论程序执行是否正常,该通知都会执行。

10.5.3 AspectJ 的切入点表达式

在这里插入图片描述

表达式 指定切入点
execution(public * *(…)) 任意公共方法。
execution(* set *(…)) 任何一个以“set”开始的方法。
execution(* com.xyz.service..(…)) 定义在 service 包里的任意类的任意方法。
execution(* com.xyz.service….(…)) 定义在 service 包或者子包里的任意类的任意方法。 “…”出现在类名中时,后面必须跟“*” ,表示包、子包下的所有类。
execution(* .service..doSome()) 只有一级包下的 serivce 子包下所有类中的 doSome()方法为切入点
execution(* …service..doSome()) 所有包下的 serivce 子包下所有类中的 doSome()方法为切入点
execution(* com.xyz.service.IAccountService.*(…)) IAccountService 接口中的任意方法。
execution(* com.xyz.service.IAccountService+.*(…)) IAccountService 若为接口,则为接口中的任意方法及其所有实现类中的任意方法;若为类,则为该类及其子类中的任意方法。
execution(* joke(String,int))) 所有的 joke(String,int)方法,且 joke()方法的第一个参数是 String,第二个参数是 int。如果方法中的参数类型是 java.lang 包下的类,可以直接使用类名,否则必须使用全限定类名,如 joke( java.util.List, int)。
execution(* joke(String,*))) 所有的 joke()方法,该方法第一个参数为 String,第二个参数可以是任意类型, 如 joke(String s1,String s2)和 joke(String s1,double d2)都是, 但 joke(String s1,double d2,String s3)不是。
execution(* joke(String,…))) 所有的 joke()方法,该方法第 一个参数为 String,后面可以有任意个参数且参数类型不限,如 joke(String s1)、joke(String s1,String s2)和 joke(String s1,double d2,String s3)都是。
execution(* joke(Object)) 所有的 joke()方法,方法拥有一个参数,且参数是 Object 类型。 joke(Object ob)是,但,joke(String s)与 joke(User u)均不是。
execution(* joke(Object+))) 所有的 joke()方法, 方法拥有一个参数, 且参数是 Object 类型或该类的子类。不仅 joke(Object ob)是,joke(String s)和 joke(User u)也是。

10.6.3 实践

10.6.3.1 引入依赖

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>4.2.1.RELEASE</version>
</dependency>

10.6.3.2 Aspect 基于注解的 AOP 实现

  1. 在定义的 POJO 类上添加@Aspect 注解,指定当前 POJO 类将作为切面。
    在这里插入图片描述

  2. 在 POJO 类的普通方法上添加通知注解
    在这里插入图片描述

  3. 注册目标对象与 POJO 切面类
    在这里插入图片描述

  4. 注册 AspectJ 的自动代理
    在定义好切面 Aspect 后,需要通知 Spring 容器,让容器生成“目标类 + 切面”的代理对象。这个代理是由容器自动生成的。只需要在 Spring 配置文件中注册一个基于 aspectj 的自动代理生成器,其就会自动扫描到@Aspect 注解,并按通知类型与切入点,将其织入,并生成代理。
    在这里插入图片描述

11、Spring 配置文件读取属性文件

属性文件名称随意,但一般都是放在 src 下。

11.1 < bean/ > 方式(不常用)

< bean/ > 方式 -使用 class 为 PropertyPlaceholderConfigurer
在这里插入图片描述

11.2 < context:property-placeholder /> 方式

该方式要求在 Spring 配置文件头部加入 context 的约束,即修改配置文件头。
< context:property-placeholder/ > 标签中有一个属性 location,用于指定属性文件的位置。

在这里插入图片描述

12、Spring 配置文件从属性文件中读取数据

在 < property/> 的 value 属性中使用${ }
在这里插入图片描述

13、Spring 的事务管理

事务原本是数据库中的概念,在 Dao 层。但一般情况下,需要将事务提升到业务层,
即 Service 层。这样做是为了能够使用事务的特性来管理具体的业务

13.1 异常

受查异常,也叫编译时异常,即在代码编写时要求必须捕获或抛出的异常,若不处理,则无法通过编译。 如 SQLException, ClassNotFoundException, IOException 等都属于受查异常。

RuntimeException 及其子类以外的异常, 均属于受查异常。 当然, 用户自定义的 Exception
的子类,即用户自定义的异常也属受查异常。程序员在定义异常时,只要未明确声明定义的
为 RuntimeException 的子类,那么定义的就是受查异常。

14、Spring 配置文件最全约束

<beans xmlns="http://www.springframework.org/schema/beans" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  xmlns:context="http://www.springframework.org/schema/context" 
  xmlns:aop="http://www.springframework.org/schema/aop"  
  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/context  
        http://www.springframework.org/schema/context/spring-context.xsd 
        http://www.springframework.org/schema/tx  
        http://www.springframework.org/schema/tx/spring-tx.xsd 
        http://www.springframework.org/schema/aop  
        http://www.springframework.org/schema/aop/spring-aop.xsd"> 
 
</beans>

15、Spring 在 Web 项目中的使用

15.1 Spring 容器的创建语句

15.1.1 放在 Servlet 初始化语句中

一个 Web 应用只需要一个 Spring 容器,因此把 Spring 容器的创建语句放在 Servlet 初始化语句中,即 init() 方法中。但是每个业务都会有一个 Servlet, 都会执行自己的 init()方法,
也就都会创建一个 Spring 容器了。这样一来,Spring 容器就又不唯一了。

15.1.2 使用 Spring 的 Web 插件

对于 Web 应用来说,ServletContext 对象是唯一的,一个 Web 应用,只有一个ServletContext 对象。该对象是在 Web 应用装载时初始化的, 即在 Web 应用装载时会自动执
行接口 ServletContext 的初始化方法。 该初始化方法在整个应用中只会执行一次。 将 Spring 容器的创建语句放到 ServletContext 的初始化方法中执行,并将创建好的 Spring 容器作为ServletContext 的属性放入其中。以后再需要 Spring 容器,直接读取该属性值即可。

已经被封装到 spring-web-4.2.1.RELEASE.jar 中。
引入该依赖 ——> 注册监听器 ContextLoaderListener ——> 指定 Spring 配置文件的位置 < context-param/> ——> 修改 Spring 配置文件中映射文件路径的写法(spring-web 中代码要求,Spring 配置文件中映射文件的路径前必须添加 classpath:)——> 通过 WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc) 获取 Spring 容器

Aoing97 发布了34 篇原创文章 · 获赞 1 · 访问量 631 私信 关注

标签:容器,配置文件,Spring,实践,Bean,Demo,org,属性
来源: https://blog.csdn.net/qq_39120849/article/details/104400816

专注分享技术,共同学习,共同进步。侵权联系[admin#icode9.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有