Spring框架(入门到精通二)

重生之我在CSDN学java 第七天（配置整合）

一、DAO(Data Access Object) 支撑

Spring提供的DAO(数据访问对象)支持主要的目的是便于以标准的方式使用不同的数据访问技术，不仅可以方便地在这些持久化技术间切换， 而且在编码的时候不用考虑处理各种技术中特定的异常。

1. 一致的异常体系 Spring提供了一种方便的方法，把特定于某种技术的异常，如SQLException， 转化为自己的异常，这种异常属于以DataAccessException 为根的异常层次。这些异常封装了原始异常对象，这样就不会有丢失任何错误信息的风险。
2. 一致的DAO支持抽象类 为了便于以一种一致的方式使用各种数据访问技术，如JDBC、JDO和Hibernate， Spring提供了一套抽象DAO类供你扩展。这些抽象类提供了一些方法，通过它们你可以 获得与你当前使用的数据访问技术相关的数据源和其他配置信息。

1. 数据访问整合

1. 工程依赖

Spring DAO支撑是基于IOC和AOP的，在IOC和AOP的工程依赖基础上需要导入DAO支撑相关的包，如果是Maven工程，则需要加入以下依赖配置

  <!--spring-jdbc：必选，spring jdbc整合包 -->
        <!--依赖传递导入：spring-tx-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
        <!--mysql-jdbc：必选 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>>${mysql-connector-java-version}</version>
        </dependency>

2. 配置文件

<?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: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/aop
http://www.springframework.org/schema/aop/spring-aop.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">
</beans>

2. 整合JDBC

1、 applicationContext_jdbc.xml

<?xml version="1.0" encoding="UTF-8"?>
        <!-- 数据源 -->
<bean id="dataSource"
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <!--<property name="driverClassName"
    value="oracle.jdbc.driver.OracleDriver" />
    <property name="url" value="jdbc:oracle:thin:@localhost:1521:xe" />-->
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url"
              value="jdbc:mysql://localhost:3306/spring?
useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=GMT%2B8"/>
    <property name="username" value="hr" />
    <property name="password" value="hr" />
</bean>
        <!-- jdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource">
    <ref bean="dataSource" />
</property>
</bean>
        <!-- DAO -->
<bean id="userDAO"
      class="com.demo.spring.sample.step05.jdbc.dao.impl.UserDAO">
<property name="jdbcTemplate">
    <ref bean="jdbcTemplate" />
</property>
</bean>
        <!-- DAO -->
<bean id="userDAO2"
      class="com.demo.spring.sample.step05.jdbc.dao.impl.UserDAO2">
<property name="dataSource">
    <ref bean="dataSource" />
</property>
</bean>
 </beans>

2、 UserDAO.java
使用模板辅助类

import com.demo.spring.sample.step05.jdbc.dao.IUserDAO;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.jdbc.core.JdbcTemplate;

public class UserDAO implements IUserDAO {
    private static Logger logger = LogManager.getLogger(UserDAO.class);
    private JdbcTemplate jdbcTemplate = null;
    public void create(int id) {
        jdbcTemplate.execute("insert into users(user_id) values(" + id + ")");
    }
    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
}

3、UserDAO2.java
使用支持类

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class UserDAO2 extends JdbcDaoSupport {
	private static Logger logger = LogManager.getLogger(UserDAO2.class);
	public void create(int id) {
		super.getJdbcTemplate().execute("insert into users(user_id) values(" +
		id + ")");
	}
}

3. 事务管理

Spring基于APO提供了事务管理，框架的事务支持提供了一致的事务管理抽象，这带来了以下好处：

1. 为复杂的事务API提供了一致的编程模型，如JTA、JDBC、Hibernate、JPA和JDO
2. 提供比大多数复杂的事务API（诸如JTA）更简单的，更易于使用的编程式事务管理API
3. 支持声明式事务管理
4. 与Spring的各种数据访问抽象完美结合

声明式事务

1. 基于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: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/aop
http://www.springframework.org/schema/aop/spring-aop.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">
    <!-- 数据源 -->
    <bean id="dataSource"
          class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"
        />
        <property name="url" value="jdbc:oracle:thin:@localhost:1521:xe" />
        <property name="username" value="hr" />
        <property name="password" value="hr" />
    </bean>
    <!-- 事务管理器 -->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 所有已get开头的方法使用只读事务 -->
            <tx:method name="get*" read-only="true" />
            <tx:method name="create*" propagation="REQUIRED" read-only="false"
                       rollback-for="java.lang.RuntimeException" />
            <!-- 其他方法使用默认的事务设置 -->
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>
    <!-- 在所有的service代码中织入事务通知 -->
    <aop:config>
        <aop:pointcut id="service"
                      expression="execution(* com.demo.spring..service.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="service" />
    </aop:config>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource">
            <ref bean="dataSource" />
        </property>
    </bean>
    <bean id="userDao"
          class="com.demo.spring.sample.step04.dao.impl.UserDAOImpl">
        <property name="jdbcTemplate">
            <ref bean="jdbcTemplate" />
        </property>
    </bean>
    <bean id="userService"
          class="com.demo.spring.sample.step04.service.impl.UserServiceImpl">
        <property name="userDao">
            <ref bean="userDao" />
        </property>
    </bean>
</beans>

2. 基于注解配置的事务

将事务通知和切面的定义放入了java代码中

<?xml version="1.0" encoding="UTF-8"?>
<beans ...>
        <!-- 数据源 -->
<bean id="dataSource"
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"
/>
<property name="url" value="jdbc:oracle:thin:@localhost:1521:xe" />
<property name="username" value="hr" />
<property name="password" value="hr" />
</bean>
        <!-- 事务管理器 -->
<bean id="transactionManager"
      class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
        <!-- 使用annotation注解方式配置事务 -->
        <!-- 在Service的方法或者类加入@Transactional注解，该注解默认的设置如下： -->
        <!-- **传播行为: PROPAGATION_REQUIRED. -->
        <!-- **隔离级别:ISOLATION_DEFAULT. -->
        <!-- **读写:读/写。 -->
        <!-- **事务超时默认为基础事务系统的默认超时，如果不支持超时，则默认为none。 -->
        <!-- **任何RuntimeException、Error都会触发回滚，而任何检查Exception都不会触发回滚。
        -->
<tx:annotation-driven transaction-manager="transactionManager" />
</beans>

二、脱离XML配置Spring

1. 注解和XML混合配置

在最大化使用注解后，Spring的配置文件大致如下

<?xml version="1.0" encoding="UTF-8"?>
<beans ...>
        <!--由自动扫描和BeanPostProcessor处理bean的实例化和依赖注入-->
<context:component-scan basepackage="com.demo.spring.sample.step07.**.service" />
        <!-- 数据源 -->
<bean id="dataSource"
      class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
    <property name="url" value="jdbc:oracle:thin:@localhost:1521:XE" />
    <property name="username" value="hr" />
    <property name="password" value="hr" />
</bean>
        <!-- 事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
        <!-- jdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

<property name="dataSource">
    <ref bean="dataSource" />
</property>
</bean>
        <!--事务切面由@Transactional定义-->
<tx:annotation-driven transaction-manager="transactionManager" />
</beans>

2. 注解和Java代码配置

Spring3开始支持通过Java代码来配置Spring，Spring的配置可以完全脱离XML，通过注释和Java代码来配置，常用注释如下

1. @Configuration，表明当前类提供Spring配置文件的作用，Spring上下文会从当前类的注解中提取配置信息

@Configuration
public class AppConfig {
}

相当于一个配置文件

2. @Import，导入其他类提供配置信息，也可以在初始化上下文时指定多个

@Configuration
@Import(JDBCConfig.class)
public class AppConfig {
}

3. @ComponentScan， 开启组件扫描

@Configuration
@Import(JDBCConfig.class)
@ComponentScan(basePackages = "com.demo.spring.sample.step")
public class AppConfig {
}

相当于： <context:component-scan basepackage="com.demo.spring.sample.step03" />

4. @EnableAspectJAutoProxy，启用@AspectJ切面

@Configuration
@Import(JDBCConfig.class)
@ComponentScan(basePackages = "com.demo.spring.sample.step")
@EnableAspectJAutoProxy
public class AppConfig {
}

相当于： <aop:aspectj-autoproxy />

5. @EnableTransactionManagement ，启用注解事务

@Configuration
@Import(JDBCConfig.class)
@ComponentScan(basePackages = "com.demo.spring.sample.step")
@EnableAspectJAutoProxy
@EnableTransactionManagement
public class AppConfig {
}

相当于： <tx:annotation-driven />

6. @ImportResource，导入XML格式的配置文件

@Configuration
@Import(JDBCConfig.class)
@ComponentScan(basePackages = "com.demo.spring.sample.step")
@EnableAspectJAutoProxy
@EnableTransactionManagement
@ImportResource("classpath:/com/acme/properties-config.xml")
public class AppConfig {
}

XML配置文件的名称空间特有标签使用起来比较方便，可以使用这种方式与Java API方式混合使用

7. @PropertySource，导入属性资源

@Configuration
@Import(JDBCConfig.class)
@ComponentScan(basePackages = "com.demo.spring.sample.step")
@EnableAspectJAutoProxy
@EnableTransactionManagement
@ImportResource("classpath:/com/acme/properties-config.xml")
@PropertySource(value = {"classpath:jdbc.properties"})
public class AppConfig {
}

相当于： <context:property-placeholderlocation="classpath:jdbc.properties"/>

8. @bean，放在方法前，表示该方法返回一个对象实例

@Configuration
@Import(JDBCConfig.class)
@ComponentScan(basePackages = "com.demo.spring.sample.step")
@EnableAspectJAutoProxy
@EnableTransactionManagement
@ImportResource("classpath:/com/acme/properties-config.xml")
@PropertySource(value = {"classpath:jdbc.properties"})
public class AppConfig {

    @Bean // 表示这个方法实例化一个bean，id=user1,同方法名
    public User user1() {
        return new User();
    }

    @Bean(name = "user2") // 表示这个方法实例化一个bean，id=user2,指定name
    public User user2() {
        return new User();
    }

    @Bean(name = "user3")
    @Scope("prototype") // bean的范围
    public User user3() {
        return new User();
    }

    @Bean(name = "user4")
    @Scope("prototype") // bean的范围
    public User user4() {
        User user4=new User();
        //可以引用其他@bean方法实例化的对象，如果同类型只有一个实例，最好通过参数传入
        user4.setInnerUser(user3());
        return user4;
    }

   /* @Bean(name = "user5")
   @Scope("prototype")
   public User user5(User user) {
        User user4=new User();
        user4.setInnerUser(user);
        return user4;
   }*/
}
}

相当于： <bean id="user"class="com.demo.spring.sample.step.service.bo.User"/>
注意：如果@Bean方法返回的是实现BeanPostProcessor或者BeanFactoryPostProcessor
接口的bean，则该方法在容器初始化阶段被调用，如果@Bean方法是非静态方法，会导致
AppConfig提前实例化。 提前实例化会导致AppConfig实例的增强失败，本类中的
@Value、@Autowired失效

9. @Value，使用上下文中的属性

@Configuration
@Import(JDBCConfig.class)
@ComponentScan(basePackages = "com.demo.spring.sample.step")
@EnableAspectJAutoProxy
@EnableTransactionManagement
@ImportResource("classpath:/com/acme/properties-config.xml")
@PropertySource(value = {"classpath:jdbc.properties"})
public class AppConfig {
@Value("${jdbc.ur}")
private String url;
}

示例

Step.java

import com.demo.spring.sample.step.config.AppConfig;
import com.demo.spring.sample.step.config.JDBCConfig;
import com.demo.spring.sample.step.service.IUserService;
import com.demo.spring.sample.step.service.bo.User;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import
        org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
 * 1：基于Java的配置和基于XML的配置是可以共存的: <br/>
 * ----XML中一些基于命名空間的配置还是比较有优势的,如果以Java配置为中心，则可以使用
 @ImportResource导 入XMl配置
  * ----如果以XML配置为中心，可以将@Configuration的类注册为bean，当然也可以通过注解扫描自动
 注册
  *
 */
public class Step {
    static AnnotationConfigApplicationContext context = null;
    static {
// 使用AnnotationConfigApplicationContext作为应用上下文，在web环境下用
        AnnotationConfigWebApplicationContext
                context = new AnnotationConfigApplicationContext();
        context.register(AppConfig.class, JDBCConfig.class);
        context.refresh();
    }
    private static Logger logger = LogManager.getLogger(Step.class);
    public static void main(String[] args) throws Exception {
        User user = (User) context.getBean("user1");
        IUserService userService = (IUserService)
                context.getBean("userService");
        User user2=new User();
        user2.setId(1231);
        userService.create(user2);
    }
}

AppConfig.java

import com.demo.spring.sample.step.service.bo.User;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration // 表明当前类提供Spring配置文件的作用，Spring上下文会从当前类的注解中提取配
置信息
//@Import(JDBCConfig.class) //导入其他类提供配置信息，也可以在初始化上下文是指定多个
@ComponentScan(basePackages = "com.demo.spring.sample.step") // 开启组件扫描
@EnableAspectJAutoProxy
@EnableTransactionManagement //启用事务管理
//@ImportResource("classpath:/com/acme/properties-config.xml"),如果混合使用基于java
和xml的配置，而以java配置为中心，则可以导入xml配置
@PropertySource(value = {"classpath:jdbc.properties"})//导入属性资源
public class AppConfig {
    private static Logger logger = LogManager.getLogger(AppConfig.class);
    @Value("${jdbc.ur}")//使用上下文中的属性
    private String url;
    @Bean // 表示这个方法实例化一个bean，id=user1,同方法名
    public User user1() {
        logger.debug( "从属性文件获取到的属性："+url );
        return new User();
    }
    @Bean(name = "user2") // 表示这个方法实例化一个bean，id=user2,指定name
    public User user2() {
        return new User();
    }
    @Bean(name = "user3")
    @Scope("prototype") // bean的范围
    public User user3() {
        return new User();
    }
}

JDBCConfig.java

package com.demo.spring.sample.step.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
/**
 * 事务配置
 */
@Configuration
public class JDBCConfig {
    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.ur}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
    @Bean
    public JdbcTemplate jdbcTemplate() {
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
//调用dataSource()，相当于获取dataSource() 定义的bean，多次调用不会生成多个实例
        jdbcTemplate.setDataSource(dataSource());
        return jdbcTemplate;
    }
    /**
     * 基于java的配置中，事务管理器的默认名称为txManager
     *
     * @return
     */
    @Bean
    public PlatformTransactionManager txManager() {
        return new DataSourceTransactionManager(dataSource());
    }
}

TraceLog.java

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class TraceLog {
    private static Logger logger = LogManager.getLogger(TraceLog.class);
    public TraceLog() {
        logger.debug("TraceLog");
    }
    @After("execution(* com.demo.spring..service.*.*(..))")
    public void after() {
        logger.debug("最终通知");
    }
}

UserService.java

import com.demo.spring.sample.step.dao.IUserDAO;
import com.demo.spring.sample.step.service.IUserService;
import com.demo.spring.sample.step.service.bo.User;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service("userService")
public class UserService implements IUserService {
    private static Logger logger = LogManager.getLogger(UserService.class);
    @Autowired
    private IUserDAO userDao = null;
    @Transactional
    public void create(User user) {
        userDao.create(user.getId());
    }
}

UserDAO.java

import com.demo.spring.sample.step.dao.IUserDAO;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
/**
 *
 */
@Repository
public class UserDAO implements IUserDAO {
    private static Logger logger = LogManager.getLogger(UserDAO.class);
    @Autowired
    private JdbcTemplate jdbcTemplate = null;
    public void create(int id) {
//两次插入，模拟数据库抛出异常，事务回滚
        jdbcTemplate.execute("insert into users(user_id) values("+id+")");
//jdbcTemplate.execute("insert into users(user_id) values("+id+")");
    }
}

三、Spring Test与Junit

Spring Test整合使用Junit需要导入以下包

spring-test：spring测试模块
junit-4.12.jar：Junit测试包
hamcrest-core-1.3.jar：Junit依赖该包

Maven依赖导入

        <!--spring-test：必选，spring项目方法编程的依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${org.springframework-version}</version>
            <scope>test</scope>
        </dependency>
        <!--junit：必选，junit包 -->
        <!--依赖传递导入：hamcrest-core -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

1. 独立使用Junit

/**
 * 直接使用JUnit
 */
public class UserServiceOTest1 {
    private static IUserService userService;
    /*初始化测试环境*/
    @BeforeClass
    public static void init() {
        ApplicationContext applicationContext = new
                ClassPathXmlApplicationContext("com/demo/spring/sample/step10/applicationContext
                .xml");
                userService = (IUserService) applicationContext.getBean("userService");
    }
    /*测试用例*/
    @Test
    public void testGetAcccountById() {
        userService.create();
    }
}

2. Spring test整合Junit

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:com/demo/spring/sample/step10/applicationContext.xml")
//Java配置方式的测试上下文：@ContextConfiguration(classes = MvcConfig.class)
public class UserServiceOTest2 {
    @Autowired
    private IUserService userService;
    /*测试用例*/
    @Test
    public void testGetAcccountById() {
        userService.create();
    }
}

Spring 整合Junit使用方法：
1. 继续使用 Junit4 测试框架，包括其 @Test 注释标签和相关的类和方法的定义，这些都不用变
2. 通过 @RunWith(SpringJUnit4ClassRunner.class) 来启动 Spring 对测试类的支持
3. 通过 @ContextConfiguration 注释标签来指定 Spring 配置文件或者配置类的位置
4. 通过 @Transactional 来启用自动的事务管理,测试数据自动回滚
5. 可以使用 @Autowired 自动织入 Spring 的 bean 用来测试
不再需要：
6. 手工加载 Spring 的配置文件
7. 手工清理数据库的每次变更
8. 手工获取 application context 然后获取 bean 实例

四、Spring-Web

1. 工程依赖

  <!--spring-web：spring-web必选-->
        <!--依赖传递导入：-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
        <!-- ********************* JAVAEE API *********************-->
        <!-- Servlet API-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${javax.servlet-api-version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- JSP API-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>${javax.servlet.jsp-api-version}</version>
            <scope>provided</scope>
            7.2. 初始化Spring容器
            Spring 既可以在JavaSE中使用，也可以在JavaEE环境中使用，在Web环境下可以借助Spring-Web提供
            的监听器初始化Spring容器。如：
            7.3. 在Servlet中获取容器
            在Servlet中可以借助WebApplicationContextUtils获取初始化的Spring容器
        </dependency>
        <!-- JSTL -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl-version}</version>
        </dependency>

2. 初始化Spring容器

Spring 既可以在JavaSE中使用，也可以在JavaEE环境中使用，在Web环境下可以借助Spring-Web提供的监听器初始化Spring容器。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
		http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <!-- <param-value> /WEB-INF/applicationContext*.xml </param-value>-->
        <param-value>classpath:applicationContext*.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
</web-app>

3. 在Servlet中获取容器

在Servlet中可以借助WebApplicationContextUtils获取初始化的Spring容器

/**
 * 演示Spring-Web的Servlet
 */
@WebServlet("/userServlet")
public class UserServlet extends HttpServlet {
    private static final Log logger= LogFactory.getLog(UserServlet.class);
    private WebApplicationContext applicationContext;
    private IUserService userService = null;
    @Override
    public void init(ServletConfig config) throws ServletException {
        applicationContext =
                WebApplicationContextUtils.getWebApplicationContext(config.getServletContext());
        userService = (IUserService) applicationContext.getBean("userService");
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws
            ServletException, IOException {
        logger.info("------------doPost--------------");
        int id=Integer.parseInt(req.getParameter("id"));
        String name=req.getParameter("name");
        userService.create(new User(id,name));
    }
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws
            ServletException, IOException {
        logger.info("------------doGet--------------");
        doPost(req, resp);
    }
}