目录
一.什么是spring?
spring是以IOC(控制反转)和AOP(面向切面编程)为内核的轻量级开源框架,可以看作是一个容器通过集成其它框架技术来完成对JavaEE企业级的开发,同时还提供了表现层和持久层以及业务层的事务管理等技术。
优点
- 方便解耦,简化开发
- 支持事务,整合框架
- 控制反转,切面编程
二. spring体系结构
先看一张图:
①核心依赖
spring-beans
:对bean的支持,负责配置文件,创建和管理bean,同时支持依赖注入和控制反转的操作spring-core
:其它模块的核心基础,包含一些核心的工具类spring-context
:提供上下文的支持,最关键的就是ApplicationContext。spring-expression
:spring表达式语言,帮助spring运行时查询和操作对象,获取对象的属性和方法的调用。
②AOP模块:功能与代码分离
spring-aop
:对于代理AOP的支持spring-Aspects
:对于Aspect的AOP支持
③Web模块
spring-web
:提供基础的web功能,在Web项目中提供Spring的容器spring-webmvc
:提供基于Servlet的SpringMvcspring-WebSocket
:提供WebSocket功能spring-webmvc-portlet
:提供portlet支持
④数据库模块
spring-jdbc
:提供jdbc访问数据库的支持spring-tx
:提供对事物的支持的支持spring-oxm
:提供对象xml的支持spring-jms
:提供对java消息服务的支持
三. 程序的耦合和解耦
/**
* @author jektong
* @Date 2020/6/18-12:38
*/
public class JdbcTemplate {
public static void main(String[] args) throws SQLException {
Connection conn=null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
//注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//建立连接
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bookmanage?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8",
"jektong",
"123456");
//获取数据库连接的预处理对象
ps = conn.prepareStatement("select * from book");
//执行sql,得到结果集
rs = ps.executeQuery();
//遍历结果集
while (rs.next()){
System.out.println(rs.getString("bname"));
System.out.println(rs.getString("author"));
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}finally {
//释放资源
if (rs != null) {
rs.close();
}
if (ps != null) {
ps.close();
}
if (conn != null) {
conn.close();
}
}
}
}
耦合
这段代码是最初我们连接数据库的代码,当然运行此代码的时候,就必须加入mysql驱动包,不加就不会运行,这样就可以理解成程序间的耦合,也就是程序间的存在的依赖关系。依赖关系包括类之间的依赖和方法间的依赖。.
解耦
降低依赖关系:
- 用反射来创建对象,避免用new这个关键字
- 使用配置文件来获取到创建对象的全限定类名
四.控制反转和依赖注入
依赖注入(Dependency Inhection)
是一种开发的设计思想,在没有提出这个思想之前,我们就需要硬编码的方式去创建对象,然后在赋值给其他的对象,更要命的是还要用代码去管理他们的生命周期,DI提出后直接用框架来去管理这些杂七杂八的东西的,我们唯一要做的就是将对象组织封装起来,调用它们的业务方法。
Spring框架出来后,实例对象不需手动创建,由Spring容器来自动创建,控制权直接由代码转给容器,发生了反转,就叫做控制反转(Inversion of Control)
。再从Spring容器的角度来看,Spring负责被依赖的对象赋值给调用者的成员变量,相当于为调用者注入它依赖的实例,就是Spring的依赖注入。
IOC(控制反转)Spring的核心,就是由Spring容器来负责控制对象的生命周期和对象之间的关系。
Spring所倡导的就是所有的类都会在Spring容器中进行登记,你需要什么东西的时候,它会交给你什么东西,类的创建和销毁由Spring控制,也就是说控制对象的生命周期的不是引用的对象而是Spring。简单来说,以前都是它来控制对象,现在所有的对象都交给Spring来控制(IOC)。
案例理解spring
Hello.java
:包含一个str的变量
/**
* @author jektong
* @Date 2020/6/18-22:34
*/
public class Hello {
private String str;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
beans.xml
:相当于将对象交给spring托管的容器,放在类路径下
<?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">
<!--id名自取,class写注入的全限定类名-->
<bean id="hello" class="bean.Hello">
<!--name为要赋值的变量名,value写要赋的值-->
<property name="str" value="hello,spring"></property>
</bean>
</beans>
HelloTest.java
/**
* @author jektong
* @Date 2020/6/18-22:45
*/
public class HelloTest {
public static void main(String[] args) {
//加载beans.xml文件
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//从容器中获取bean
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.getStr());
}
}
ApplicationContext
当加载配置文件的时候会将所管理的类进行实例化
它有两个实现类:
ClassPathXmlApplicationContext
:加载类路径下的xml配置文件
FileSystemXmlApplicationContext
加载文件系统(磁盘)下的配置文件
五.IOC创建对象bean三种方式
1.使用默认的构造函数创建
上述的代码案例的方式就是通过默认的构造函数创建的,如果没有这个默认的构造函数,对象就会无法创建
<bean id="hello" class="bean.Hello"/>
2.使用普通工厂的方法创建对象
改造上面的案例:
建造一个普通的工厂InstanceFactory.java
使用getHello()
这个方法来创建对象
InstanceFactory.java
这个工厂类可能存在jar包中,不允许修改的
/**
* @author jektong
* @Date 2020/6/19-14:11
*/
public class InstanceFactory {
public Hello getHello(){
return new Hello();
}
}
在beans.xml
文件中改造
<!---->
<bean id="instanceFactory" class="bean.InstanceFactory"></bean>
<bean id="hello" factory-bean="instanceFactory" factory-method="getHello">
<property name="str" value="hello,spring"></property>
</bean>
3.使用工厂中的静态方法创建对象
如果将上述的工厂中方法加入static
关键字后,普通工厂创建对象就会无效,此时应修改beans.xml文件
:
<bean id="hello" class="bean.InstanceFactory" factory-method="getHello">
<property name="str" value="hello,spring"/>
</bean>
上述输出的代码结果都是 hello,spring
六.bean的作用范围
spring中bean对象的作用范围通过修改scope属性的值来进行指定的,有以下两种:
singleton
:单例,也是默认值,怎么get都只有一个对象prototype
:多例对象,每一次从容器中get时都会产生一个对象
七.bean的生命周期
单例对象
出生:容器创建,对象创建
活着:容器在,对象就在
死亡:容器销毁,对象消失
当容器被创建的时候此对象就会产生,只要这个容器存在,则这个对象就会存在,容器消失,对象也就会消失。
多例对象
出生:使用时,容器创建对象
活着:对象使用就一直存在
死亡:对象长时间不用时,且没有其他对象的调用,交个GC回收
使用对象的时候,spring就会为我们创建,只要被使用了就会一直存在,当对象长时间不用的时候,并且有没有别的对象进行引用的时候Java的垃圾回收机制就会来回收这些对象。
八.依赖注入的三种方式
准备一个Student类,相关属性如下:
/**
* @author jektong
* @Date 2020/6/19-19:44
*/
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String, String> map;
private Set<String> games;
private String wife;
private Properties info;
}
//略去toString方法和setter,getter方法
1.构造方法注入
上面的案例一开始就是用了默认的构造方法注入,若类中带有参数的构造方法时,beans.xml
应改为:
构造方法有多少参数就要注入多少<constructor-arg>
,这里构造方法参数只有一个name,且没有默认的构造方法。
<bean id="hello" class="bean.Hello">
<constructor-arg name="str" value="hello,spring"></constructor-arg>
</bean>
2.set注入
现在使用Student这个类,Spring容器中注入各种数据
<bean id="address" class="bean.Address"></bean>
<bean id="name" class="bean.Student">
<!--普通注入-->
<property name="name" value="John"></property>
<!--Bean的注入,也就是使用类进行注入-->
<property name="address" ref="address"></property>
<!--数组的注入-->
<property name="books">
<array>
<value>水浒传</value>
<value>西游记</value>
<value>三国演义</value>
<value>红楼梦</value>
</array>
</property>
<!--list数据注入-->
<property name="hobbys" >
<list>
<value>打球</value>
<value>打网球</value>
<value>打乒乓球</value>
</list>
</property>
<!--map集合注入-->
<property name="map">
<map>
<entry key="k1" value="v1"></entry>
<entry key="k2" value="v2"></entry>
</map>
</property>
<!--set集合注入-->
<property name="games">
<set>
<value>LOL</value>
<value>CS</value>
</set>
</property>
<!--null注入-->
<property name="wife">
<null/>
</property>
<!--prop注入-->
<property name="info">
<props>
<prop key="username">John</prop>
<prop key="password">John</prop>
<prop key="age">21</prop>
</props>
</property>
</bean>
3.p命名空间的注入
这里将name以p命名空间进行注入:
<bean id="name" class="bean.Student" p:name="John"/>
输出的结果就是John