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 层

 1 package com.shore.dao;
 2 
 3 /**
 4  * @author DSHORE/2019-10-15
 5  *
 6  */
 7 public class UserDao {
 8     private String name;
 9 
10     public void save() {
11         System.out.println(name + "用户保存成功");
12     }
13     
14     public String getName() {
15         return name;
16     }
17     public void setName(String name) {
18         this.name = name;
19     }
20 }

Service 层

 1 package com.shore.service;
 2 
 3 import com.shore.dao.UserDao;
 4 
 5 /**
 6  * @author DSHORE/2019-10-15
 7  *
 8  */
 9 public class UserService {
10     
11     private UserDao userDao;
12     
13     public void save(){
14         userDao.save();
15     }
16 
17     public UserDao getUserDao() {
18         return userDao;
19     }
20     public void setUserDao(UserDao userDao) {
21         this.userDao = userDao;
22     }
23 }

Action 层

 1 package com.shore.action;
 2 
 3 import com.shore.service.UserService;
 4 
 5 /**
 6  * @author DSHORE/2019-10-15
 7  *
 8  */
 9 public class UserAction {
10     
11     private UserService userService;
12     
13     public String save() {
14         userService.save();
15         return "success";
16     }
17 
18     public UserService getUserService() {
19         return userService;
20     }
21     public void setUserService(UserService userService) {
22         this.userService = userService;
23     }
24 }

applicationContext.xml 配置文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:aop="http://www.springframework.org/schema/aop"
 5        xmlns:tx="http://www.springframework.org/schema/tx"
 6        xsi:schemaLocation="
 7        http://www.springframework.org/schema/beans
 8        http://www.springframework.org/schema/beans/spring-beans.xsd
 9        http://www.springframework.org/schema/tx
10        http://www.springframework.org/schema/tx/spring-tx.xsd
11        http://www.springframework.org/schema/aop
12        http://www.springframework.org/schema/aop/spring-aop.xsd">
13   
14            <!-- 
15               id——指定bean对象的id
16               class——指定bean的类，不能用接口
17               scope——单例/多例，默认是单例“singleton”（此时在初始化容器之前就创建对象），多例：用到的时候才创建
18               lazy-init——懒加载，只针对单例有效，默认是false，如果是true——用到的时候才创建
19               init-method——指定对象的初始化方法，时间由创建对象的时间来决定
20             -->
21             <!-- UserDao userDao = new UserDao() -->
22         <bean id="userDao" class="com.shore.dao.UserDao" scope="singleton"><!-- 默认是单例，可不写 -->
23             <property name="name" value="DSHORE"></property>
24         </bean>
25     
26         <bean id="userService" class="com.shore.service.UserService">
27             <property name="userDao" ref="userDao"></property>
28         </bean>    
29         
30         <bean id="userAction" class="com.shore.action.UserAction" scope="prototype"><!-- prototype：多例 -->
31             <property name="userService" ref="userService"></property>
32         </bean>   
33 </beans>

测试类：

 1 package com.shore.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;
 5 
 6 import com.shore.action.UserAction;
 7 
 8 /**
 9  * @author DSHORE/2019-10-15
10  * 
11  */
12 public class MyTest {
13     @Test
14     public void test() {
15         // 创建IoC容器
16         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
17         UserAction userAction = (UserAction) context.getBean("userAction");
18         System.out.println("UserAction返回给struts.xml的值：" + userAction.save());
19     }
20 }

测试结果：

 

 

 

 

 

 

原创作者：DSHORE

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

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

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）
posted @ 2019-10-15 20:58  DSHORE  阅读(280)  评论(0)  编辑  收藏  举报