Spring笔记
第一节:Spring框架概念、模块划分与环境搭建
Spring框架概念
Spring 是众多开源 java 项目中的一员,基于分层的 javaEE 应用一站式轻量级开源框架,主要核心是 Ioc(控制反转/依赖注入) 与 Aop(面向切面)两大技术,实现项目在开发过程中的轻松解耦,提高项目的开发效率。在项目中引入 Spring 立即可以带来下面的好处 降低组件之间的耦合度,实现软件各层之间的解耦。可以使用容器提供的众多服务,如:事务管理服务、消息服务等等。当我们使用容器管理事务时,开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。容器提供单例模式支持,开发人员不再需要自己编写实现代码。 容器提供了 AOP 技术,利
用它很容易实现如权限拦截、运行期监控等功能。
Spring结构图
Spring的划分
层级 | 作用 | 对应的框架 |
---|---|---|
Dao层 | JDBC处理(BeseDao) | MyBatis |
Service | 实现业务逻辑 | Spring框架不是针对Service的业务逻辑,没有合适的框架 |
Web层(Controller层) | 接收请求,返回响应 | SpringMVC |
Spring基于分布式的应用程序
Spring是基于轻量级的框架,存在以下技术
- 配置管理
- Bean对象的实例化-IOC
- 集成其他第三方技术,例如MyBatis、Hibernate(持久化框架)、SpringMVC
- 自带的服务,例如:Mail邮件处理、定义任务处理-定时调度(定时短信、定时任务)、消息异步处理
Spring模块划分-重点
模块 | 作用 |
---|---|
Spring IOC模块 | Bean对象实例化 Bean的创建 |
Spring AOC模块 | 动态代理 面向切面编程 |
Spring JDBC+事物 | |
Spring Web模块 |
Spring的环境搭建
1.新建Maven项目
选择"File"->选择"New"->选择Maven
2.设置项目的坐标
3.设置项目的Maven环境
4.设置项目的名称和存放的工作空间
5.修改项目中pom.xml的配置
5.1修改JDK的版本
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!--其他版本改成1.8-->
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
5.2修改单元测试的版本
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<!--其他版本改成4.12-->
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
5.3删除build标签中的pluginManagement标签
<!--删除build标签中的pluginManagement标签-->
<build>
</build>
5.4添加Spring的依赖坐标
Maven仓库:https://mvnrepository.com/
<!--添加Spring的依赖坐标-->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.9.RELEASE</version>
</dependency>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="..." class="...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<bean id="..." class="...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- more bean definitions go here -->
</beans>
6.添加Spring的配置文件Spring.xml
6.1在src/main下新建一个resources文件,将其标记为Resources Root
6.2在其目录下,新建一个spring.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="..." class="...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<bean id="..." class="...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- more bean definitions go here -->
</beans>
7.创建Bean对象
8.通过Spring.xml配置Bean对象
修改Spring.xml的id和class的值
<!--id为唯一标识,其他资源会到这个配置文件找,class表示引用资源的地址,一般为包名+类名-->
<bean id="userService" class="com.shsxt.service.UserService"></bean>
其他文件件使用时候,需要先引入这个文件,会根据id值找到对应的class的值,会找到包下的类名
9.加载配置文件,获取实例化对象
public static void main(String[] args) {
// 加载配置文件,获取Spring上下文环境
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
// 通过getBean方法得到Spring容器中实例化好的Bean对象
UserService userService = (UserService) ac.getBean("userService");
// 调用方法
userService.test();
}
第二节:Spring IOC容器Bean对象实例化模拟
1.引入dom4j的依赖和jaxen的依赖,将其加载到pom.xml配置文件中
<!--dom4j的依赖-->
<!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<!--jaxen的依赖-->
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.1</version>
</dependency>
2.准备一个Bean
public class WzmBean {
private String id;
private String clazz;
public WzmBean() {
}
public WzmBean(String id, String clazz) {
this.id = id;
this.clazz = clazz;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getClazz() {
return clazz;
}
public void setClazz(String clazz) {
this.clazz = clazz;
}
}
3.准备一个BeanFactory工厂接口
public interface Wzmfactory {
Object getBean(String bean);
}
4.实现类(实现BeanFactory工厂)
public class WzmClassPathXmlApplicationContext implements Wzmfactory {
private List<WzmBean> beans;//存放bean
private Map<String,Object> target=new HashMap<String,Object>();//用于存放id和实例化的对象
/* 模拟SPring实现
* 1.通过构造器得到相关配置文件
* 2.通过dom4j解析xml文件,得到List,存放id和class
* 3.通过反射实例化得到的对象
* 4.得到指定实例化对象
*
* */
//1.通过构造器得到相关配置文件
public WzmClassPathXmlApplicationContext(String fileName) throws DocumentException, ClassNotFoundException, InstantiationException, IllegalAccessException {
//1.1通过dom4j解析xml文件
this.parseXml(fileName);
//1.2通过反射实例化对象
this.instanceBean();
}
//1.1通过dom4j解析xml文件,得到的是一个存放好bean对象的容器
private void parseXml(String fileName) throws DocumentException {
//1.1.1获取解析器
SAXReader reader=new SAXReader();
//1.1.2得到配置文件的url
URL url=this.getClass().getClassLoader().getResource(fileName);
//1.1.3通过解析器解析xml文件
Document document=reader.read(url);
//1.1.4通过指定语法,获取元素 beans下的所有bean
XPath xPath=document.createXPath("beans/bean");
//1.1.5将获取的bean设置到集合中
List<Element> list=xPath.selectNodes(document);
//1.1.6判断集合(bean)是否为空,不为空,将获取id对应的值和获取到的class对应的值设置到对象中
if (list!=null&&list.size()>0){
//1.1.6.1设置一个对象集合Bean,用于存放对象
beans=new ArrayList();
//1.1.6.2遍历集合(bean元素集合)
for (Element el:list){
//id对应的值
String idBean=el.attributeValue("id");
//class对应的值
String clazzBean=el.attributeValue("class");
//将id对应的值 和 class对应的值,设置到对象中
WzmBean wzmBean=new WzmBean(idBean,clazzBean);
//将设置到对象,设置到集合中
beans.add(wzmBean);
}
}
}
//1.2通过反射实例化对象
private void instanceBean() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
//1.2判断beans是否为空,不为空,将其实例化,并存储到Map中
if (beans!=null&&beans.size()>0){
//遍历beans中的每个对象
for (WzmBean bean:beans) {
//将每一个对象,都设置到Map中,第一个参数 id值,第二个参数实例化好的对象
target.put(bean.getId(),Class.forName(bean.getClazz()).newInstance());
}
}
}
//返回一个创建好的实例
@Override
public Object getBean(String bean) {
return target.get(bean);
}
}
5. Test类
package com.shsxt.test;
import com.shsxt.service.UserService;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
class test01 {
public static void main(String[] args){
//方式一:用application方式接收spring.xml文件的内容
ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");
//通过getBean方法得到Spring容器中实例化好的Bean对象
UserService userService= (UserService) ac.getBean("userService");
//调用方法
userService.test();
//方式二:用Beanfactory接收获取工厂
BeanFactory factory=new ClassPathXmlApplicationContext("spring.xml");
//通过getBean方法得到spring容器中实例化的Bean对象
UserService userService01= (UserService) factory.getBean("userService");
//调用方法
userService01.test();
}
}
6.总结
Spring IOC核心技术
模式 |
---|
工厂设计模式(简单工厂 工厂方法 抽象方法)–可参考大话设计模式.pdf |
XML解析(Dom4j) |
反射(实例化对象,反射获取方法,反射获取属性,反射获取构造器,反射方法调用) |
策略模式(加载资源) |
单例(IOC创建的实例化对象都是单例) |
第三节:Spring IOC配置文件加载&Bean对象实例化
Spring IOC配置文件加载
方式一:根据相对路径加载资源(只需要修改测试文件即可)
ApplicationContext ac01=new ClassPathXmlApplicationContext("spring.xml");
方式二:根据绝对路劲加载资源(只需要修改测试文件即可)
ApplicationContext ac02=new FileSystemXmlApplicationContext("E:\\sxtallfile\\formal\\Third\\studentCode\\maven_idea\\mavensecond\\spring02\\src\\main\\resources\\spring.xml");
Test文件
class test02 {
public static void main(String[] args){
//前:方式一采用相对路径加载配置文件
//用application方式接收spring.xml文件的内容
ApplicationContext ac01=new ClassPathXmlApplicationContext("spring.xml");
//通过getBean方法得到Spring容器中实例化好的Bean对象
UserService userService01= (UserService) ac01.getBean("userService");
//调用方法
userService01.test();
//前:方式二:采用绝对路径加载配置文件
//用application方式接收spring.xml文件的内容,这里采用绝对路径
ApplicationContext ac02=new FileSystemXmlApplicationContext("E:\\sxtallfile\\formal\\Third\\studentCode\\maven_idea\\mavensecond\\spring02\\src\\main\\resources\\spring.xml");
//通过getBean方法得到Spring容器中实例化好的Bean对象
UserService userService02= (UserService) ac02.getBean("userService");
//调用方法
userService02.test();
}
}
方式三:多文件加载
1.可变参数引入
ApplicationContext ac01=new ClassPathXmlApplicationContext("spring.xml","dao.xml");
2.通过总的配置文件import其他配置文件(xml文件都是放在src/main/resources下)
dao.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userDao" class="com.shsxt.dao.UserDao">
</bean>
</beans>
spring.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userService" class="com.shsxt.service.UserService">
<!-- collaborators and configuration for this bean go here -->
</bean>
</beans>
manage.xml文件,引入上面两个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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="dom.xml"/>
<import resource="spring.xml"/>
</beans>
测试文件
public class test03 {
public static void main(String[] args) {
//1.同时加载多个资源文件
ApplicationContext ac=new ClassPathXmlApplicationContext("dom.xml","spring.xml");
//2.1通过getBean()方法得到Spring容器中实例好的Bean对象 userService
UserService userService= (UserService) ac.getBean("userService");
//2.2通过getBean()方法得到Spring容器中是实例好Bean对象 userDao
UserDao userDao= (UserDao) ac.getBean("userDao");
//2.3测试实例对象的方法
userService.test();
userDao.test();
}
}
Spring IOC Bean对象实例化
方式一:通过bean的缺省构造函数实例化Bean对象
注:通过默认构造器创建 空构造方法必须存在,否则创建失败
Test文件(test)
//用application方式接收spring.xml文件的内容
ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");
//通过getBean方法得到Spring容器中实例化好的Bean对象
UserService userService= (UserService) ac.getBean("userService");
//调用方法
userService.test();
配置文件(spring1.xml)
<bean id="userService" class="com.shsxt.service.UserService">
<!-- collaborators and configuration for this bean go here -->
</bean>
方式二:通过静态工厂实例化Bean
Test文件(test)
public class test04 {
public static void main(String[] args) {
//1.加载资源文件
ApplicationContext ac=new ClassPathXmlApplicationContext("spring03.xml");
//2.通过静态工厂获取Bean对象
UserController userController= (UserController) ac.getBean("userController");
//3.测试Bean对象的方法
userController.test();
//4.检查是否单例
System.out.println("是否单例:"+ac.isSingleton("userController"));
}
}
配置文件(spring2.xml)
<bean id="userController" class="com.shsxt.factory.StaticFactory" factory-method="createUsersService"></bean>
方式三:实例化工厂创建Bean
Test文件(test)
public class test04 {
public static void main(String[] args) {
//1.加载资源文件
ApplicationContext ac=new ClassPathXmlApplicationContext("spring03.xml");
//2.通过静态工厂获取Bean对象
UserController userController= (UserController) ac.getBean("userController");
//3.测试Bean对象的方法
userController.test();
//4.检查是否单例
System.out.println("是否单例:"+ac.isSingleton("userController"));
}
}
配置文件(spring3.xml)
<!--实例工厂-->
<bean id="intanceFactory" class="com.shsxt.factory.IntanceFactory"></bean>
<bean id="userController" factory-bean="intanceFactory" factory-method="createUser"></bean>
XmlApplicationContext(“spring03.xml”);
//2.通过静态工厂获取Bean对象
UserController userController= (UserController) ac.getBean(“userController”);
//3.测试Bean对象的方法
userController.test();
//4.检查是否单例
System.out.println(“是否单例:”+ac.isSingleton(“userController”));
}
}
##### 配置文件(spring3.xml)
```xml
<!--实例工厂-->
<bean id="intanceFactory" class="com.shsxt.factory.IntanceFactory"></bean>
<bean id="userController" factory-bean="intanceFactory" factory-method="createUser"></bean>