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

时间：2022-08-12 00:11:06

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的几大模块

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

     }

 }

测试结果：

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

原创作者：DSHORE

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

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

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

相关文章