一、Spring框架讲解
1.1 Spring简介
Spring框架是一个开放源代码的J2EE应用程序框架,由Rod Johnson发起,是针对bean的生命周期进行管理的轻量级容器(lightweight container)。
Spring解决了开发者在J2EE开发中遇到的许多常见的问题,提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序,也可以和Struts、Webwork、Tapestry等众多Web框架组合使用,并且可以与 Swing等桌面应用程序AP组合。因此, Spring不仅仅能应用于JEE应用程序之中,也可以应用于桌面应用程序以及小应用程序之中。Spring框架主要由七部分组成,分别是 Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC。
1.2 传统开发存在问题
1.2.1 案例展示
- 编写Dog类
public class Dog {
public void hello(){
System.out.println("你好,我是小狗汪汪汪");
}
}
- 编写Cat类
public class Cat {
public void hello(){
System.out.println("你好,我是小猫喵喵喵");
}
}
- 编写测试类
public class User {
//说明: 当前类中 Dog对象与User对象绑定.耦合性高
//如果需要切换Cat对象.则需要手动修改代码.
//所以得出结论,如果自己实例化对象,则不能实现很好的解耦.
private static Dog dog = new Dog();
//private static Cat cat = new Cat();
public static void main(String[] args) {
dog.hello();
}
}
1.2.2 问题说明
- 对象与方法 紧紧的绑定在一起. 耦合性高
1.3 面向接口开发
1.3.1 业务说明
- Dog类中和Cat类中都有hello的方法. 可以将hello的方法进行抽取,代码逐步演化为面向接口的方式.
1.3.2 定义封装Pet接口
1.3.2.1 Pet接口
//定义一个宠物的接口
public interface Pet {
void hello();
}
1.3.2.2 编辑Dog与Cat的实现类
- Dog类
public class Dog implements Pet{
public void hello(){
System.out.println("你好,我是小狗汪汪汪");
}
}
- Cat类
public class Cat implements Pet{
public void hello(){
System.out.println("你好,我是小猫喵喵喵");
}
}
1.3.2.3 测试
public class User {
//通过定义接口对象.以后用户直接使用属性,后续操作无需修改属性名
//接口中赋值的实现类可以灵活的变化. 所以在一定程度上 降低了耦合性
private static Pet pet = new Cat();
public static void main(String[] args) {
pet.hello();
}
}
1.3.3 小结
- 使用接口开发,可以在一定程度上 降低类与对象的耦合性. 提高开发效率.
通过定义接口对象,用户可以直接使用属性,后续操作无需修改属性名称。
接口中赋值的实现类可以灵活的变化,所以在一定程度上降低了耦合度。
定义接口前:
定义接口后:
使用面向接口开发,虽然能在一定程度上降低代码的耦合性. 但是属性与类绑定的事实,并没有解决。
如何解决该问题呢?
1.4 Spring-IOC(Inversion of Control)-控制反转
1.4.1 IOC介绍
Ioc全称Inversion of Control,即**“控制反转”,这是一种设计思想**。对象创建的权利由Spring框架完成.由容器管理对象的生命周期
- 原来的对象的创建都是由用户自己手动创建,这样的方式耦合性 肯定高. 如果类发生了变化,则代码都得修改.
- 现在所有的对象都交给Spring容器管理. 用户无需关心对象是如何实例化. 容器负责对象的注入即可. 以后几乎不用修改任何代码. 降低了代码的耦合性
1.4.3 创建User类
package com.chuci.demo;
public class User {
public void say(){
System.out.println("我是User对象,被Spring容器管理");
}
}
1.4.4 编辑spring.xml配置文件
说明: 由于需要使用Spring的框架,所以需要准备spring的配置文件.
在resource中创建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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
该配置文件作用是管理对象
术语: bean 被spring容器管理的对象称之为bean
属性说明:
id: 是spring容器中对象的唯一标识符.不能重复
class: 对象的全路径
-->
<bean id="user" class="com.jt.demo.User"></bean>
<!--<bean id="user" class="com.jt.demo.User"/>-->
</beans>
1.4.5 测试API
package com.chuci;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpring {
//spring管理对象的测试API
@Test
public void testDemo1(){
String resource = "spring.xml";
//创建spring容器. 并且加载指定的配置文件 对象已经交给容器管理
ApplicationContext context =
new ClassPathXmlApplicationContext(resource);
//从容器中获取对象
User user1 = (User) context.getBean("user");
User user2 = context.getBean(User.class);
user2.say();
}
}
1.5 关于Spring容器
解释:
Spring容器的数据结构是Map集合. Map<key,value>
key=“user” value=“通过反射机制实例化的对象”
<bean id="user" class="com.jt.demo.User"></bean>
1.6 了解反射源码
说明: 反射机制在框架中 一般使用比较多,给定类型的路径就可以获取其中的对象.但是要求必须有无参构造. 否则程序运行必报异常.
@Test
public void testDemo2() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
User user =
(User) Class.forName("com.jt.demo.User").newInstance();
user.say();
}
二、 Spring 注解开发
2.1 关于Spring注解开发的说明
大约在2015年以前 框架的开发需要大量的xml配置文件。导致项目配置比较臃肿,开发效率略低. 但是项目整合时的 报错概率很高. Spring与时俱进 从3开始逐步演化为注解开发. 到了SpringBoot框架的诞生,标志着进入了全注解时代.
2.2 注解开发的步骤
2.2.1编辑User类
package com.jt.demo;
public class User {
public void say(){
System.out.println("使用全注解的方式管理对象");
}
}
2.2.2 编辑配置类
说明: 原始的开发使用xxx.xml文件 用来管理对象, 现在都使用java类的形式当作配置文件则将该java类 称之为配置类.
package com.jt.config;
import com.jt.demo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration //将当前类标识为配置类
public class SpringConfig {//xml
/**
* 1.xml形式
* <bean id="user" class="com.jt.demo.User"></bean>
* 2.注解形式
* Map集合的结构 Map<方法名,方法的返回值>
* @Bean 将方法的返回值,交给Spring容器管理.
*/
@Bean
public User user(){
return new User(); //相当于xml反射机制创建对象
}
}
2.2.3 编辑测试类
package com.jt;
import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpring {
//利用注解的方式管理对象
@Test
public void testDemo1(){
//1.利用注解的方式启动spring容器
ApplicationContext context =
new AnnotationConfigApplicationContext(SpringConfig.class);
//2. 从容器中获取对象
User user = context.getBean(User.class);
//3. 对象调用方法
user.say();
}
}
2.3 关于IOC总结
- 什么是IOC 由Spring容器管理对象的生命周期,降低代码耦合性
- xml配置文件管理对象
- 准备xxx.xml配置文件
- 准备bean标签
- spring容器管理对象
ApplicationContext容器顶级接口
ClassPathXmlApplicationContext 加载配置文件的实现类对象
- 全注解的方式管理对象
-
准备配置类 @Configuration + @Bean
-
要求方法 必须有返回值
-
容器对象
ApplicationContext容器顶级接口
AnnotationConfigApplicationContext
万能语法: 根据当前spring的配置规则,实例化接口对象. 我一般不写这些代码,如果想看也可以通过ApplicationContext 查找指定的实现类.
2.4 Spring创建对象—工厂模式(必会内容)
2.4.1 关于对象管理问题说明
问题: 任意对象都可以通过new的关键字 实例化吗?
答案: 当然不是, 抽象类对象 不可以直接实例化.
2.4.2 关于spring中注解说明
@Component 将当前的类,交给Spring容器管理, 对象的创建是由Spring通过反射机制自动创建对象.
@ComponentScan(“com.jt”) 指定扫描的包路径, 可以扫描它的子孙包,用在配置类中
2.4.3 代码结构
2.4.4 代码示例
2.4.4.1 编辑配置类
package com.jt.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
//准备一个配置类
@Configuration
@ComponentScan("com.jt")
//当spring容器启动时,根据指定的包路径,扫描其子孙包
public class SpringConfig {
}
2.4.4.2 编辑User类
package com.jt.demo;
import org.springframework.stereotype.Component;
//Spring容器管理 Map<类名首字母小写:user,实例化的对象>
@Component
public class User { //spring容器通过反射机制实例化对象
public void say(){
System.out.println("通过@Component注解实例化对象");
}
}
2.4.4.3 编辑测试类
package com.jt;
import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class TestSpring {
@Test
public void testDemo1(){
ApplicationContext context =
new AnnotationConfigApplicationContext(SpringConfig.class);
User user = context.getBean(User.class);
user.say();
}
}
2.4.5 利用工厂模式创建对象(了解)
2.4.5.1 业务说明
Spring中管理的对象,大部分可以通过new/反射进行对象的创建. 但是有些对象由于特殊的原因.不能直接new/实例化.这时需要考虑是否可以通过工厂模式实现.
例如: Calendar 该类是一个抽象类 所以不能直接实例化
2.4.5.2 创建工厂模式
- 创建工厂模式
package com.jt.factory;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;
import java.util.Calendar;
/**
* FactoryBean是Spring提供的接口,spring自动完成调用.获取指定的对象
* 难点讲解:
* 1.@Component 标识类 则将该类交给Spring容器管理.
* 2.Spring中FactoryBean的讲解
* 如果spring加载的时候遇到FactoryBean接口
* 则会自动的执行重写的方法getObject/getObjectType
* 3.工厂模式说明:
* Map<Key:calendar,value=Calendar对象></>
*
* 核心功能:
* 1. key: 就是当前类型(如果自己编辑注解以注解为准)
* 2. value: 调用getObject获取的返回值对象
* 将上述的数据,交给Spring容器管理
* 该功能什么时候使用:
* 1. 某些对象不能直接实例化的.
* 2. 整合其它第三方框架对象时 经常使用.
*/
@Component("calendar")
public class CalendarFactory implements FactoryBean<Calendar> {
public CalendarFactory(){
System.out.println("工厂模式的无参构造");
}
//现阶段 大家理解为主. 未来写结构设计的时候,作用很大!!!!!
//动态执行该方法,获取返回值对象
@Override
public Calendar getObject() throws Exception {
//利用calendar的工具API 实现对象的创建
return Calendar.getInstance();
}
@Override
public Class<?> getObjectType() {
//固定写法. 一般直接xxx.class即可
return Calendar.class;
}
}
- 编辑测试API
@Test
public void testDemo2(){
ApplicationContext context =
new AnnotationConfigApplicationContext(SpringConfig.class);
//Calendar calendar = context.getBean(Calendar.class);
Calendar calendar = (Calendar) context.getBean("calendar");
System.out.println("获取当前时间:"+calendar.getTime());
System.out.println("获取年:"+calendar.getWeekYear());
}
2.5 注解复习
注解 | 解释 |
---|---|
@Configuration | 标识配置类 |
@Bean | 将自己方法的返回值交给Spring容器管理 |
@Component | 将该类交给spring容器管理. 通过反射自动实例化对象 |
@ComponentScan(“com.jt”) | 包扫描的注解 使Spring注解有效 |
至此,本节完~~~
此 系 列 以 完 整 记 录 自 己 在 J a v a 学 习 路 的 过 程 此系列以完整记录自己在Java学习路的过程 此系列以完整记录自己在Java学习路的过程