Java进阶知识15 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

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