Spring简讲第一卷

简介

Spring是什么

• Spring是分层的Java SE/EE应用full-stack轻量级开源框架
• 以loC( Inverse OfControl:反转控制）和AOP ( Aspect Oriented Programming :面向切面编程)为内核。
• 提供了展现层SpringMVC和持久层Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的JavaEE企业应用开源框架.

Spring发展历程

• 1997年，IBM提出了EJB的思想
• 1998年，SUN制定开发标准规范EJB1.01999年，EJB1.1发布
• 2001年，EJB2.0发布
• 2003年，EJB2.1发布2006年，EJB3.0发布

Rod Johnson(Spring之父)

• Expert One-to-One J2EE Design and Development(2002)
• 阐述了J2EE使用EJB开发设计的优点及解决方案
• Expert One-to-OneJ2EE Development without EJB(2004)
• 阐述了J2EE开发不使用EJB的解决方式(Spring雏形)

2017年9月份发布了Spring的最新版本Spring5.0通用版(GA)

Spring优势

1. 方便解耦，简化开发
   • 通过Spring提供的loC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬偏码所造成的过度耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
2. AOP编程的支持
   • 通过Spring的AOP功能，方便进行面向切面编程，许多不容易用传统OOP实现的功能可以通过AOP轻松实现。
3. 声明式事务的支持
   • 可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务管理，提高开发效率和质量。
4. 方便程序的测试
   • 可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
5. 方便集成各种优秀框架
   • Spring对各种优秀框架(Struts、Hibernate、Hessian、Quartz等）的支持。
6. 降低JavaEE API的使用难度
   • Spring对JavaEE APIl(如JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些API的使用难度大为降低。
7. Java源码是经典学习典范
   • Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。

Spring的体系结构

Spring快速入门

Spring程序开发步骤

1. 导入Spring开发的基本包坐标
2. 编写Dao接口和实现类
3. 创建Spring核心配置文件
4. 在Spring配置文件中配置UserDaoImpl
5. 使用Spring的API获得Bean实例

Spring快速入门代码实现

UserDao - 接口

public interface UserDao {
    public void save();
}

UserDaoImpl - 实现类

@Override
public void save() {
    System.out.println("save running....");
}

UserDaoDemo - 测试类

//创建Spring客户端对象
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取xml配置文件中的文件对象
UserDao userDao = (UserDao) app.getBean("UserDao");
//调用方法
userDao.save();

applicationContext.xml - Spring核心配置文件

• resources -> New -> XML Configuration File -> SpringConfig

<bean id="UserDao" class="com.ytzl.dao.impl.UserDaoImpl"></bean>

Spring配置文件

Bean标签基本配置

• 用于配置对象交由Spring来创建
• 默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功

基本属性

<bean id="UserDao" class="com.ytzl.dao.impl.UserDaoImpl"></bean>

属性	说明
id	Bean实例在Spring容器中的唯一标识
calss	Bean的全限定名称(文件路径)

Bean标签范围配置

• scope：指对象的作用范围，取值如下：

取值范围	说明
singleton	单例的(默认)
prototype	多例的
request	WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中
session	WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中
global session	WEB项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession相当于session

创建时机

1. 当scope的值为singleton时
   • Bean的实例化个数：1个
   • Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
   • Bean的生命周期
     • 对象创建：当应用加载，创建容器时，对象就被创建了
     • 对象运行：只要容器在，对象一直活着
     • 对象销毁：当应用卸载，销毁容器时，对象就被销毁了
2. 当scope的值为prototype时
   • Bean的实例化个数：多个
   • Bean的实例化时机：当调用getBean()方法时实例化Bean
   • Bean的生命周期
     • 对象创建：当适用对象时，创建新的对象
     • 对象运行：只要对象在使用中，就一直活着
     • 对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了

Bean生命周期配置

属性	说明
init-method	指定类中的初始化方法名称
destroy-method	指定类中销毁方法名称

Bean实例化三种方式

• 无参构造方法实例化

  • public interface UserDao {
        public void save();
    }
    

  • <bean id="UserDao" class="com.ytzl.dao.impl.UserDaoImpl"></bean>
    

• 工厂静态方法实例化

  • public static UserDao getUserDao(){
        return new UserDaoImpl();
    }
    

  • <bean id="UserDao" class="com.ytzl.factory.StaticFactory" factory-method="getUserDao"></bean>
    

• 工厂实例方法实例化

  • public UserDao getUserDao(){
        return new UserDaoImpl();
    }
    

  • <bean id="factory" class="com.ytzl.factory.DynamicFactory"></bean>
    <bean id="UserDao" factory-bean="factory" factory-method="getUserDao"></bean>
    

Bean的依赖注入

概念

• 依赖注入：它是Spring框架核心IOCd饿具体实现
• 在编写程序时，通过控制反转，把对象的创建交给了Spring，但是代码中不可能出现没有依赖的情况。
• IOC解耦只是降低他们的依赖关系，但不会消除。例如:业务层仍会调用持久层的方法。
• 那这种业务层和持久层的依赖关系，在使用Spring之后，就让Spring来维护了。
• 简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

Bean的依赖注入分析

• 目前UserService实例和UserDao实例都存在与Spring容器中

• 当前的做法是在容器外部获得UserService实例和UserDao实例，然后在程序中进行结合。
  

• 因为UserService和UserDao都在Spring容器中，而最终程序直接使用的是UserService

• 所以可以在Spring容器中，将UserDao设置到UserService内部。

Bean的依赖注入方式

• 怎么将UserDao怎样注入到UserService内部呢？

set方法1 – 代码实现

UserDao - 接口

public void save();

UserDaoImpl - 实现

public UserDaoImpl() {
    System.out.println("UserDaoImpl创建...");
}
@Override
public void save() {
    System.out.println("save running....");
}

UserService - 接口

public void save();

UserServiceImpl - 实现

private UserDao userDao;

public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

@Override
public void save() {
    userDao.save();
}

applicationContext.xml - 配置文件

<bean id="UserDao" class="com.ytzl.dao.impl.UserDaoImpl"></bean>
<bean id="UserService" class="com.ytzl.service.impl.UserServiceImpl">
    <property name="userDao" ref="UserDao"></property>
</bean>

UserController - 测试

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) app.getBean("UserService");
        userService.save();

set方法2 – 代码实现

1. beans标签引入P命名空间

   • xmlns:p="http://www.springframework.org/schema/p"
     

2. 修改注入方式

   • <bean id="UserService" class="com.ytzl.service.impl.UserServiceImpl" p:userDao-ref="UserDao"/>
     

构造方法 – 代码实现

UserServiceImpl

private UserDao userDao;
public UserServiceImpl(UserDao userDao) {
    this.userDao = userDao;
}

public UserServiceImpl() {
}
@Override
public void save() {
    userDao.save();
}

<bean id="UserDao" class="com.ytzl.dao.impl.UserDaoImpl"></bean>
<bean id="UserService" class="com.ytzl.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="UserDao"></constructor-arg>
</bean>

Bean的依赖注入的数据类型

• 上面的操作，都是注入的引用Bean，
• 除了对象的引呵以注入，普通数据类型，集合等都可以在容器中进行注入。

引用数据类型

Bean

普通数据类型

UserDaoImpl - 实现

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

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public void save() {
        System.out.println(name+"==>"+age);
        System.out.println("save running....");
    }

applicationContext.xml

<bean id="UserDao" class="com.ytzl.dao.impl.UserDaoImpl">
    <property name="name"  value="葛霄"/>
    <property name="age"  value="18"/>
</bean>
<bean id="UserService" class="com.ytzl.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="UserDao"/>
</bean>

集合数据类型

<bean id="UserDao" class="com.ytzl.dao.impl.UserDaoImpl">
    <property name="strList">
        <list>
            <value>1</value>
            <value>2</value>
            <value>3</value>
            <value>玫瑰到了花期</value>
        </list>
    </property>
    <property name="userMap">
        <map>
            <entry key="u1" value-ref="user1"></entry>
            <entry key="u2" value-ref="user2"></entry>
        </map>
    </property>
    <property name="properties">
        <props>
            <prop key="p1">p</prop>
            <prop key="p2">pp</prop>
            <prop key="p3">ppp</prop>
        </props>
    </property>
</bean>

<bean id="user1" class="com.ytzl.domain.User">
    <property name="name" value="葛霄"/>
    <property name="addr" value="三门峡"/>
</bean>
<bean id="user2" class="com.ytzl.domain.User">
    <property name="name" value="尚奇奇"/>
    <property name="addr" value="洛阳"/>
</bean>

<bean id="UserService" class="com.ytzl.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="UserDao"/>
</bean>

引入其他配置文件（分模块开发）

• 实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，
• 所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载

<import resource="applicationContext-user.xml"/>

知识要点

Spring的重点配置

• <bean>标签

  • id属性:在容器中Bean实例的唯一标识，不允许重复
  • class属性:要实例化的Bean的全限定名
  • scope属性:Bean的作用范围，常用s是singleton(默认)和prototype
  • <property>标签：属性注入
    • name属性：属性名称
    • value属性：注入的普通属性值
    • ref属性：注入的对象引用值标签
    • <map>标签
    • <properties>标签
  • <constructor-arg>标签

• <import>标签:导入其他的spring的分文件

标签 – 览

标签	说明
bean	用于配置对象
property	依赖注入
constructor-arg	有参构造依赖注入

属性 – 览

属性	说明
Bean
id	Bean实例唯一标识
calss	文件路径
scope	对象的作用范围
init-method	初始化方法名称
destroy-method	销毁方法名称
factory-method	静态实例化方法名
依赖注入
name	需要注入的文件的set方法
ref	bean的id标识

Spring相关API

ApplicationContext的继承体系

• applicationContext:接口类型，代表应用上下文，
• 可以通过其实例获得Spring容器中的Bean对象

ApplicationContext的实现类

• ClassPathXmlApplicationContext

  • 它是从类的根路径下加载配置文件 – 推荐

• FileSystemXmlApplicationContext

  • 它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置
  • 参数绝对路径

• AnnotationConfigApplicationContext

  • 当使用注解配置容器对象时，需要使用此类来创建Spring容器。它用来读取注解

getBean()方法使用

1. UserService userService = (UserService) app.getBean("UserService");
   

2. UserService userService = app.getBean(UserService.class);
   

• 其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。
• 当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，
• 当容器中相同类型的Bean有多个时,则此方法会报错。

知识要点

Spring的重点API

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//一样类型的bean存在多个
app.getBean("id")
//一样类型的bean只存在一个
app.getBean(class)

Spring配置数据源

数据源（连接池）的作用

• 数据源(连接池)是提高程序性能出现的

• 事先实例化数据源，初始化部分连接资源

• 使用连接资源时从数据源中获取

• 使用完毕后将连接资源归还给数据源

• 常见的数据源（连接池）：

  • DBCP、C3P0、BoneCP、Druid等

数据源的开发步骤

1. 导入数据源的坐标和数据库驱动坐标
2. 创建数据源对象
3. 设置数据源的基本连接数据
4. 使用数据源获取链接资源和归还链接资源

数据源的手动创建

手动创建 c3p0 数据源

@Test
//测试手动创建 c3p0 数据源
public void test1() throws Exception {
    //1.创建数据源对象
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    //2.设置基本的链接参数
    dataSource.setDriverClass("com.mysql.jdbc.Driver");
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/spring");
    dataSource.setUser("root");
    dataSource.setPassword("123456");
    //3.获取资源
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    //归还数据源
    connection.close();
}

手动创建 druid 数据源

@Test
//测试手动创建 druid 数据源
public void test2() throws Exception {
    //1.创建数据源对象
    DruidDataSource dataSource = new DruidDataSource();
    //2.设置基本的链接参数
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/spring");
    dataSource.setUsername("root");
    dataSource.setPassword("123456");
    //3.获取资源
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    //归还数据源
    connection.close();
}

使用properties配置文件创建数据源

jdbc.properties - 数据库配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/spring
username=root
password=123456

Test - 测试

@Test
//测试手动创建 c3p0 数据源 加载配置文件形式
public void test3() throws Exception {
    //1.读取配置文件
    ResourceBundle rb = ResourceBundle.getBundle("jdbc");
    //2.赋值
    System.out.println(1);
    String driver = rb.getString("driver");
    String url = rb.getString("url");
    String username = rb.getString("username");
    String password = rb.getString("password");
    //3.创建数据源对象 设置链接参数
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass(driver);
    dataSource.setJdbcUrl(url);
    dataSource.setUser(username);
    dataSource.setPassword(password);
    //4.获取资源
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    //5.归还
    connection.close();
}

Spring配置数据源

• 可以将DataSource的创建权交由Spring容器完成

Spring配置c3p0数据源

applicationContext.xml - 配置

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring"/>
    <property name="user" value="root"/>
    <property name="password" value="123456"/>
</bean>

@Test - 测试

@Test
//测试Spring容器产生数据源对象
public void test4() throws Exception {
    ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
    DataSource dataSource = app.getBean(DataSource.class);
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

Spring配置druid数据源

applicationContext.xml - 配置

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</bean>

@Test - 测试

@Test
//测试Spring容器产生 druid 数据源对象
public void test5() throws Exception {
    ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
    DataSource dataSource = app.getBean(DataSource.class);
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

Spring抽取jdbc配置文件

• applicationContext.xml加载jdbc.properties配置文件获得连接信息。

1. 引入context命名空间和约束路径

   • 命名空间

     • xmlns:context="http://www.springframework.org/schema/context"
       

   • 约束路径

     • http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       

• <!--加载外部的properties文件-->
  <context:property-placeholder location="classpath:jdbc.properties"/>
  
  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
          <property name="driverClassName" value="${jdbc.driver}"/>
          <property name="url" value="${jdbc.url}"/>
          <property name="username" value="${jdbc.username}"/>
          <property name="password" value="${jdbc.password}"/></bean>
  

Spring注解开发

• Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势

• 注解代替xml配置文件可以简化配置，提高开发效率

• Spring原始注解主要是代替<Bean>的配置

常用注解

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired 无参	使用在字段上用于根据类型依赖注入
	按照数据类型从Spring容器中进行匹配的
@Qualifier	结合@Autowired一起使用用于根据名称进行依赖注入
	按照id值从容器中进行匹配的，此处要结合@Autowired一起用
@Resource(name)	@Resource相当于@Qualifier+@Autowired
@Value	注入普通属性
@Scope	标注Bean的作用范围
@PostConstruct	使用在方法上标注该方法是Bean的初始化方法
@PreDestroy	使用在方法上标注该方法是Bean的销毁方法

• 使用注解开发时，需要在applicationContext.xml中配置组件扫描,
• 作用是指定那个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法

Spring新注解

• 使用上面的注解还不能完全替代xml配置文件，还需要使用注解替代的配置如下：
  • 非自定义Bean的配置<bean>
  • 加载properties文件的配置<context:property-placeholder>
    • 组件扫描的配置<context:component-scan>
  • 引入其他文件<import>

注解	说明
@Configuration	用于指定当前类是一个Spring配置类，当创建容器时会从该类上加载注解
@ComponentScan	用于指定Spring的初始化容器时要扫描的包
	作用和在Spring的xml配置文件中的
	<context:component-scan base-package=“com.ytzl”/>一样 配置组件扫描
@Bean	使用方法上，标注将该方法的返回值存储到Spring容器中
	@Bean(“dataSource”) //Spring会将当前方法的返回值以指定名称存储到Spring容器当中
@PropertySource	用于加载.properties文件中的配置
	@PropertySource(“classpath:jdbc.properties”)
@Import	用于导入其他配置类

Spring整合Junit

• 原始Junit测试Spring的问题

• 在测试类中，每个测试方法都有以下两行代码

  • 

  • 这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删除

解决上述问题

• 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它
• 将需要进行测试Bean直接在测试类中进行注入

Spring继承Junit步骤

1. 导入Spring继承Junit的坐标

   • <!--        导入Spring集成Junit-->
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-test</artifactId>
                 <version>5.0.5.RELEASE</version>
             </dependency>
     

2. 使用@Runwith注解替换原来的运行器

   • @RunWith(SpringJUnit4ClassRunner.class)
     

3. 使用@ContextConfiguration指定配置文件或配置类

   • 1.@ContextConfiguration("classpath:applicationContext.xml")
     2.@ContextConfiguration(classes = {SpringConfiguration.class})
     

4. 使用@Autowired注入需要测试的对象

   • //set注入
     @Autowired
     private UserService userService;
     @Autowired
     private DataSource dataSource;
     

5. 创建测试方法进行测试

   • @Test
     public void test1() throws SQLException {
         userService.save();
         System.out.println(dataSource.getConnection());
     }
     

Spring与Web环境集成

ApplicationContext应用上下文获取方式

• 应用上下文对象是通过==new ClasspathXmlApplicationContext(Spring配置文件)==方式获取的
• 但每次容器获得Bean时都要编写new ClassPathXmlApplicationContext(Spring配置文件)
• 这样的弊端是：文件加载多次，应用上下文对象创建多次
• 在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了

ContextLoaderListener - 监听器

@Override
public void contextInitialized(ServletContextEvent sce) {
    ServletContext servletContext = sce.getServletContext();
    /* This method is called when the servlet context is initialized(when the Web application is deployed). */
    //读取web.xml中的全局参数
    String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation");
    ApplicationContext app = new ClassPathXmlApplicationContext(contextConfigLocation);
    //将Spring应用上下文对象存储到最大的域中 -- ServletContext
    servletContext.setAttribute("app",app);
    System.out.println("Spring容器创建完成");
}

WebApplicationContextUtils - 工具类

public static ApplicationContext getWebApplicationContext(ServletContext servletContext){
    return (ApplicationContext) servletContext.getAttribute("app");
};

UserServlet - 测试类

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        ServletContext servletContext = this.getServletContext();
//        ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        System.out.println("app===?"+app);
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }

web.xml - web配置文件

<!--    全局初始化参数-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
<!--    配置监听器-->
    <listener>
        <listener-class>com.ytzl.listener.ContextLoaderListener</listener-class>
    </listener>

Spring提供获取应用上下文的工具

• 上面的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象
• 所以我们需要做的只有两件事
  1. 在web.xml中配置ContextLoaderListener监听器（导入spring-web）坐标
  2. 使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

知识要点

1. 配置ContextLoaderListener监听器

   • <!--pom.xml-->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-web</artifactId>
         <version>5.2.12.RELEASE</version>
     </dependency>
     

   • <!--web.xml-->
     <!--    全局初始化参数-->
         <context-param>
             <param-name>contextConfigLocation</param-name>
             <param-value>classpath:applicationContext.xml</param-value>
         </context-param>
     <!--    配置监听器-->
         <listener>
             <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
         </listener>
     

2. 使用WebApplicationContextUtils获得应用上下文

   • ServletContext servletContext = this.getServletContext();
     ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
     
             System.out.println("app===?"+app);
             UserService userService = app.getBean(UserService.class);
             userService.save();