Java进阶知识16 Spring的基础配置详解

1、SSH各个的职责  

Struts2：是web框架（管理jsp、action、actionform等）。
Hibernate：是ORM框架，处于持久层。
Spring：是一个容器框架，用于配置bean，并维护bean直接的关系。
             Bean（组件）：java中任何一种对象，如 javabean（domin、entity、POJO、POVO）、数据源、dao、service、action等
                       比如：User、数据表user、UserDao、UserService、UserAction

2、Spring的原理  

  2.1、工作原理

      1、通过Spring容器IOC（inverse of control）动态注入，把创建对象(bean),和维护对象(bean)的关系的权利从程序中转移到spring的容器(applicationContext.xml)，而程序本身不再维护。即程序之间不用再new对象了，且方法之间也不用相互调用了，都是同过spring的容器(applicationContext.xml)来维护他们之间的关系（创建对象/调用方法等等）。

      2、通过Spring容器AOP（Aspect-Oriented Programming），可以为某一类对象进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的模块/方法）从而达到对一个模块扩充的功能。

  2.2、工作流程

      简单的理解：Struts2调用对应的xxxAction中的方法时，Spring容器根据相关的配置去调用对应的Service -->DAO -->entity -->数据库，最后把结果原路返回给调用者（Struts2）。

  2.3、相关概念

     IoC是什么？
         答：IOC（inverse of control） 控制反转：所谓控制反转就是把创建对象(bean)，和维护对象(bean)的关系的权利从程序中转移到spring的容器(applicationContext.xml)，而程序本身不再维护。

     DI是什么？
         答：DI（dependency injection）依赖注入： 实际上di和ioc是同一个概念，spring设计者认为di更准确表示spring核心技术。——> IOC 等于 DI

     AOP是什么？
         答：AOP（Aspect-Oriented Programming）面向切面编程，就是在调用某个类对象的具体方法前/后，先去调用你指定的模块/方法，最后，程序再按原来的顺序执行下去。

  2.4、Spring的几大模块

  1） Spring Core  spring的核心功能： IOC容器, 解决对象创建及依赖关系
  2） Spring Web  Spring对web模块的支持。
                --> 可以与struts整合，让struts的action创建交给spring
                --> 或者说spring mvc模式
  3） Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】
  4） Spring ORM  spring对orm的支持：
                --> 既可以与hibernate整合，【session】
                --> 也可以使用spring的对hibernate操作的封装
  5）Spring AOP  切面编程
  6）SpringEE   spring 对javaEE其他模块的支持

3、基础配置（实例解析）  

Dao 层

package com.shore.dao;

/**
 * @author DSHORE/2019-10-15
 *
 */
public class UserDao {
    private String name;

    public void save() {
        System.out.println(name + "用户保存成功");
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Service 层

package com.shore.service;

import com.shore.dao.UserDao;

/**
 * @author DSHORE/2019-10-15
 *
 */
public class UserService {
    
    private UserDao userDao;
    
    public void save(){
        userDao.save();
    }

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

Action 层

package com.shore.action;

import com.shore.service.UserService;

/**
 * @author DSHORE/2019-10-15
 *
 */
public class UserAction {
    
    private UserService userService;
    
    public String save() {
        userService.save();
        return "success";
    }

    public UserService getUserService() {
        return userService;
    }
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

applicationContext.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: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/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">
  
           <!-- 
              id——指定bean对象的id
              class——指定bean的类，不能用接口
              scope——单例/多例，默认是单例“singleton”（此时在初始化容器之前就创建对象），多例：用到的时候才创建
              lazy-init——懒加载，只针对单例有效，默认是false，如果是true——用到的时候才创建
              init-method——指定对象的初始化方法，时间由创建对象的时间来决定
            -->
            <!-- UserDao userDao = new UserDao() -->
        <bean id="userDao" class="com.shore.dao.UserDao" scope="singleton"><!-- 默认是单例，可不写 -->
            <property name="name" value="DSHORE"></property>
        </bean>
    
        <bean id="userService" class="com.shore.service.UserService">
            <property name="userDao" ref="userDao"></property>
        </bean>    
        
        <bean id="userAction" class="com.shore.action.UserAction" scope="prototype"><!-- prototype：多例 -->
            <property name="userService" ref="userService"></property>
        </bean>   
</beans>

测试类：

package com.shore.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.shore.action.UserAction;

/**
 * @author DSHORE/2019-10-15
 * 
 */
public class MyTest {
    @Test
    public void test() {
        // 创建IoC容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserAction userAction = (UserAction) context.getBean("userAction");
        System.out.println("UserAction返回给struts.xml的值：" + userAction.save());
    }
}

测试结果：

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：https://www.cnblogs.com/dshore123/p/11680766.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）