Spring
IOC本质
控制反转ioc(inversion of Control),是一种设计思想,DI(依赖注入)是实现ioc的一种方法,也有人认为只是ioc的另一种说法,没有ioc的程序中,我们使用面向对象编程,对象的创建与对象间依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓的控制反转就是:获得依赖对象的方式反转了。
采用XML方式配置Bean的时候,Bean的定义信息是和实现分离的,而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的。
控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的ioc容器,其实现方法是依赖注入(Dependency Injection,DI)。
1. IOC创建对象的方式
-
使用无参构造创建对象,默认!
-
假设我们要使用有参构造创建对象
- 下标赋值
<bean id="user" class="smxy.demo.user"> <constructor-arg index="0" value="吴伟鑫学spring"></constructor-arg> </bean>
-
类型
<bean id="user" class="smxy.demo.user"> <constructor-arg type="java.lang.String" value="22222"></constructor-arg> </bean>
-
直接通过参数名赋值
<bean id="userService" class="com.Service.UserServiceImpl"> <property name="userDao" ref="SqlDAO"></property> </bean>
总结:在配置文件加载的时候,容器中管理的对象就已经初始化了!
2. Spring配置
2.1 别名
<!--别名-->
<alias name="user" alias="user2"></alias>
2.2 Bean的配置
<!--name 可以多个的别名对应一个bean -->
<bean id="userT" class="smxy.demo.userT" name="userT2,ue,122">
<constructor-arg type="java.lang.String" value="13243"></constructor-arg>
</bean>
2.3 import
这个import,一般用于团队开发使用,他可以将多个配置文件,导入合并为一个!
<!-- 合并beans.xml文件的配置-->
<import resource="beans.xml" ></import>
3. DI(依赖注入)
3.1、构造器注入
3.2、 Set方式注入【重点】
-
依赖注入:Set注入!
- 依赖:bean对象的创建依赖于容器!
- 注入:bean对象中的所有属性,由容器来注入!
【环境搭建】
1.复杂类型
public class Address { private String addres; public String getAddres() { return addres; } public void setAddres(String addres) { this.addres = addres; } @Override public String toString() { return "Address{" + "addres='" + addres + '\'' + '}'; } }
2.真实测试对象
public class Student { private String name; private Address address; private String[] books; private List<String> hobbys; private Map<String,String> card; private Set<String> games; private String wife; private Properties info; public String getName() { return name; } public void setName(String name) { this.name = name; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } public String[] getBooks() { return books; } public void setBooks(String[] books) { this.books = books; } public List<String> getHobbys() { return hobbys; } public void setHobbys(List<String> hobbys) { this.hobbys = hobbys; } public Map<String, String> getCard() { return card; } public void setCard(Map<String, String> card) { this.card = card; } public Set<String> getGames() { return games; } public void setGames(Set<String> games) { this.games = games; } public String getWife() { return wife; } public void setWife(String wife) { this.wife = wife; } public Properties getInfo() { return info; } public void setInfo(Properties info) { this.info = info; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", address=" + address + ", books=" + Arrays.toString(books) + ", hobbys=" + hobbys + ", card=" + card + ", games=" + games + ", wife='" + wife + '\'' + ", info=" + info + '}'; } }
- beans.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 http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="address" class="com.DIdemo.Address"> <property name="addres" value="南田小学" ></property> </bean> <bean id="student" class="com.DIdemo.Student"> <property name="name" value="吴伟鑫"></property> <property name="address" ref="address"></property> </bean> </beans> ``` 4.完善注入信息 ```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 id="address" class="com.DIdemo.Address"> <property name="addres" value="南田小学" ></property> </bean> <bean id="student" class="com.DIdemo.Student"> <!--第一种,普通值注入,value--> <property name="name" value="吴伟鑫"></property> <!--第二种,bean注入,ref--> <property name="address" ref="address"></property> <!--第三种,数组注入,ref--> <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="card"> <map> <entry key="身份证" value="151231351313121"></entry> <entry key="银行卡" value="222222222213121"></entry> </map> </property> <!--Set--> <property name="games"> <set> <value>英雄联盟</value> <value>王者荣耀</value> <value>和平精英</value> </set> </property> <!--nul--> <property name="wife"> <null></null> </property> <!--Properties--> <property name="info"> <props > <prop key="学号">20170865238</prop> <prop key="出生年月">1999.05.31</prop> </props> </property> </bean> </beans> ```
3.3、拓展方式注入
我们可以使用p命令空间注入和c命令空间注入
官方解释:
p空间注入方式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GidKpXux-1615620236716)(C:\Users\24039\AppData\Roaming\Typora\typora-user-images\image-20210311161758734.png)]
c命令空间注入
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I8LUqd3K-1615620236720)(C:\Users\24039\AppData\Roaming\Typora\typora-user-images\image-20210311162047596.png)]
使用!
<?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:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--p命名空间注入,可以直接注入属性的值:property-->
<bean id="user" class="com.DIdemo.user" p:name="wwx" p:age="23"></bean>
<!--c命名空间注入,通过构造器注入:constructs-->
<bean id="user2" class="com.DIdemo.user" c:name="吴大大" c:age="18"></bean>
</beans>
测试:
@Test
public void test1()
{
ApplicationContext ac= new ClassPathXmlApplicationContext("userbeans.xml");
user usr= ac.getBean("user2",user.class);
System.out.println(usr);
}
注意点:p命名空间和c命名空间不能直接使用,需要导入xml约束!
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
3.4 bean的作用域
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1ctlcfwd-1615620236722)(C:\Users\24039\AppData\Roaming\Typora\typora-user-images\image-20210311162818565.png)]
1.单例模式(Spring默认机制)
<bean id="user2" class="com.DIdemo.user" c:name="吴大大" c:age="18" scope="singleton"></bean>
2.原型模式:每次从容器中get的时候,都会产生新的对象!
<bean id="user2" class="com.DIdemo.user" c:name="吴大大" c:age="18" scope="prototype"></bean>
3.其余的request、session、application、这些个只能在web中使用
4. Bean的自动装配
- 自动装配是Spring满足bean依赖一种方式!
- Spring会在上下文中自动寻找,并自动给bean装配属性!
在Spring中的三种装配的方式
- 在xml中显示的配置
- 在java中显示配置
- 隐式的自动装配bean 【重要的】
4.1测试
环境搭建:一个人有两只宠物!
4.2 ByName自动装配
<!--
byname:会自动在容器上下文中查找,和自己对象set方法后面值对应的beanid!
-->
<bean id="people" class="com.pojo.People" p:name="吴伟鑫" autowire="byName"></bean>
4.3 ByType 自动装配
<!--bytype:会自动在容器上下文中查找,和自己对象属性类型相同的bean!
-->
<bean id="people" class="com.pojo.People" p:name="吴伟鑫" autowire="byType"></bean>
小结:
- byname的时候,需要保证所有bean的id唯一,并且这个bean需要和自动注入的属性的set方法的值一致!
- bytype的时候,需要保证所有bean的class唯一,并且这个bean需要和自动注入的属性的类型一致!
4.4 使用注解实现自动装配
jdk1.5支持注解,Spring2.5就支持注解了!
The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.
要使用注解须知:
-
导入约束:context约束
-
配置注解的支持:context:annotation-config/
<?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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> </beans>
@
Autowired
直接在属性上使用即可!也可以在set方法上使用!
使用Autowired 我们可以不用编写set方法了,前提是你这个自动装配的属性在IOC(spring)容器中存在,且符合名字byname!
科普:
@Nullanle 字段标记了这个注解,说明这个字段可以为null;
//Autowired的实现接口 public @interface Autowired { boolean required() default true; }
测试代码:
public class People { //如果显示定义了 Autowired的required属性为false,说明这个对象可以为null,否则不允许为空 @Autowired(required = false) private Cat cat;
如果@Autowired自动装配的环境比较复杂,自动装配无法通过一个注解【@Autowired】完成的时候、我们可以使用@Qualifler( value =“XXX”)去配置@Autowired的使用,指定一个唯一的bean对象注入!
public class People { @Autowired private Cat cat; @Autowired @Qualifier(value = "dog11") private Dog dog; private String name;
@Resource注解 (Java自带的)
public class People { @Resource private Cat cat;
小结:
@Resource 和@Autowired的区别:
- 都是用来装配的,都可以放在属性字段上
- @Autowired 通过byname的方式实现,而且要求这个对象存在【常用】
- @Resource默认通过byname的方式实现,如果找不到名字,通过bytype实现!如果两个都找不到的情况下,就报错!【常用】
- 执行顺序不同:@Autowired
5. 使用注解开发
在spring4之后,要使用注解开发,必须要保证aop的包导入了
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hQMrPami-1615620236725)(C:\Users\24039\AppData\Roaming\Typora\typora-user-images\image-20210311195409656.png)]
使用注解需要导入context的约束,增加注解支持!
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:annotation-config/>
</beans>
5.1 bean
5.2 属性如何注入
//相当于 <property name="name" value="wuweixin"></property>
@Value("天天向上")
public String name;
5.3 衍生的注解
@Component有几个衍生注解,我们在web开发中,会按照mvc 三层架构分层!
- dao 【@Repository】
- service【@Service】
- controller【@Controller】
5.4自动装配置
- @Autowired:自动装配通过类型,名字
如果Autowired不能唯一自动装配上属性,则需要通过@Qualifier(value =" xxx")
- @Nullable : 字段标记了这个注释,说明这个字段可以为null
- @resource :自动装配通过名字,类型。
- @Component :组件,放在类上,说明这个类被spring管理了,就是bean。
-
5.5作用域
@Component
@Scope("prototype")
public class User {
//相当于 <property name="name" value="wuweixin"></property>
@Value("天天向上")
public String name;
}
5.6 小结
xml与注解:
- xml更加万能,适用于任何场合!维护简单方法
- 注解不是自己的类使用不了,维护相对复杂!
xml与注解最佳实践:
-
xml用来管理bean;
-
注解只负责完成属性的注入;
-
我们在使用的过程中,只需要注意一个问题:必须让注解生效,就需要开启注解支持
<!--指定要扫描的包,这个包下面的注解就会生效--> <context:component-scan base-package="com.smxy.pojo"></context:component-scan> <!--注解驱动--> <context:annotation-config/>
6.使用Java的方式配置Spring
-
我们现在要完全不使用Spring的xml配置,全权交给java来做!
Javaconfig是Spring的一个子项目,在spring4之后,它就成为了一个核心功能!
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mExEr0PV-1615620236727)(C:\Users\24039\AppData\Roaming\Typora\typora-user-images\image-20210311212755106.png)]
6.1实体类
//这里这个注解的意思,就是说明这个类被spring管理了,被注册了。
@Component
public class User {
public String name;
public String getName() {
return name;
}
@Value("wuweixin")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置类!
//这个也会被spring容器托管,因为他本来就是一个@Component
//@Configuration 代表这是一个配置类,就和我们之前看的beans.xml一样
@Configuration
@ComponentScan("com.smxy")//扫描
@Import(config2.class)
public class config {
//注册一个bean,就相当于我们之前写的一个bean。
//这个方法的名字,就相当于bean标签中的id属性
//这个方法的返回值,就相当于bean标签中的class属性
@Bean
public User getUser()
{
return new User();//就是返回注入bean的对象
}
}
测试类!
public class mytest {
@Test
public void test1()
{
//如果完全使用了配置类方式去做,我们就只能通过AnnotationConfig 上下文来获取容器,通过配置类的class对象加载!
ApplicationContext ac = new AnnotationConfigApplicationContext(config.class);
User u = ac.getBean("getUser",User.class);
System.out.println(u.name);
}
}
这种纯Java的配置方式,在SpringBoot中随处可见!
7.代理模式
为什么要学习代理模式? 因为这就是SpringAOP的底层!【SpringAOP 和 SprimngMVC】
代理模式的分类:
- 静态代理
- 动态代理
7.1 静态代理
角色分析:
- 抽象角色:一般会使用接口或者抽象类来解决
- 真实角色:被代理的角色
- 代理角色:代理真实角色后,我们一般会做一些附属操作
- 客户:访问代理对象的人
代码步骤:
- 接口
//租房
public interface Rent {
void rent();
}
2.真实角色
//房东
public class Host implements Rent {
@Override
public void rent() {
System.out.println("把房东的房子租给顾客");
}
}
3.代理角色
//中介
public class Proxy {
private Host host;
public Proxy(Host host) {
this.host = host;
}
public void Work()
{
seeHouse();
host.rent();
hetong();
fare();
}
public void seeHouse()
{
System.out.println("中介带去看房子");
}
public void hetong()
{
System.out.println("签订租赁合同");
}
public void fare ()
{
System.out.println("向房东和顾客收取中介费");
}
}
4.客户端访问代理角色
//租客
public class Client {
public static void main(String[] args) {
Host host =new Host();
Proxy proxy = new Proxy(host);
proxy.Work();
}
}
代理模式的好处:
- 可以使真实角色的操作更加的纯粹!不用去关注一些公共的业务
- 公共也就交给代理角色!实现了业务的分工!
- 公共业务发生扩展的时候,方便集中管理
缺点:
- 一个真实角色就会产生一个代理角色;代码量会翻倍,开发效率会变低
7.2 动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的,不是我们直接写好的!
- 动态代理分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口—JDK 动态代理
- 基于类:cglib
- java字节码实现:javsist
8. AOP
8.1 什么是AOP
AOP (Aspect Oriented Programming) 意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
8.2 Aop在Spring中的作用
== 提供声明式事务;允许用户自定义切面==
- 横切关注点:跨越应用程序多个模块的方式或功能。即使,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志,安全,缓存,事物等。。。
- 切面(ASPECT):横切关注点被模块化的特殊对象。即,它是一个类。
- 通知(Advice):切面必须要完成的工作,即,它是类中的一个方法。
- 目标(Target):被通知对象。
- 代理(Proxy):向目标对象应用通知之后创建的对象。
- 切入点(PoinCut):切入通知 执行的“地点”的定义。
- 连接点(JoinPoint):与切入点匹配的执行点
即AOP在不改变原有代码的情况下,去增加新的功能
8.3 使用Spring实现AOP
【重点】使用AOP织入,需要导入一个依赖包!
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>
方式一:使用Spring的API接口【主要Spring接口实现】
方式二:自定义类来实现AOP【主要切面定义】
方式三:使用注解实现!
9. 整合Mybatis
步骤:
1.导入相关的jar包
- junit
- mybatis
- mysql数据库
- spring相关的
- aop 织入
- mybatis-spring【new】
- 编写配置文件
- 测试
9.1 回忆mybatis
- 编写实体类
- 编写核心配置文件
- 编写接口
- 编写Mapper.xml
- 测试
9.2 Mybatis
- 编写数据源
- SqlSessionFactory
- SqlSessionTemplate
- 需要给接口加实现类【】
- 将自己写的实现类,注入到Spring中
- 测试使用即可!
10. 声明式事务
1. 回顾事务
- 把一组业务当成一个业务来做;要么都成功,要么都失败!
- 事务在项目开发中,十分的重要,设计到数据的一致性问题,不能马虎!
- 确保完整性和一致性;
事务ACID原则:
- 原子性(atomicity),理解就是要么全部执行成功,要么全部执行失败,否则就可能造成实例中的那种双方不开心。
- 一致性(consistency),这个怎么理解呢?你看啊,你账号中有7000点券,最后变成了1款价值6000点券的皮肤加上你账号中剩余的1000点券,即7000 = 一款皮肤(6000) + 1000,也就是价值上等价了,点券没有凭空消失,皮肤也没有凭空出现。
- **持久性(durability)**原则,也就是说你的交易完成了,这个数据就应该永远存在,按理说不应该出现实例最后那种情况。
- 隔离性(isolation),这个体会应该不是很深刻,这个特性就是说,当你在购买的过程中,这时你的点券已经被扣除,但是皮肤还没有到你的账号,假设你在另一个地点还能登陆你的账号,并查看你的点券,通常情况你应该看到的还是7000点券。就是说,这个原子性的操作没有被全部执行完成并提交,这个原子性操作的结果对你来说通常是不可见的。为什么说是通常呢?这个就需要去看一下事务的隔离级别了!~~
精简:
- 原子性(Atomicity):要么都成功、要么都失败
- 一致性(Consistency):事务前后的数据完整性要保持一致
- 隔离性(Isolation):是多个用户并发访问数据库时,数据库为每一个用户开启的事务,不能被其他事务的操作数 据所干预
- 持久性(Durability):事务提交,事务一旦提交则不可逆,被持久化到数据库中!
2. spring 中的事务管理
- 声明式事务:AOP
- 编程式事务:需要在代码中,进行事务管理
思考:
为什么需要事务?
- 如果不配置事务,可能存在数据提交不一致的情况下;
- 如果我们不在Spring 中去配置声明式事务,我们就需要在代码中手动配置事务!
- 事务在项目的开发中十分重要,设计到数据的一致性和完整性问题,不容马虎!
务ACID原则:
- 原子性(atomicity),理解就是要么全部执行成功,要么全部执行失败,否则就可能造成实例中的那种双方不开心。
- 一致性(consistency),这个怎么理解呢?你看啊,你账号中有7000点券,最后变成了1款价值6000点券的皮肤加上你账号中剩余的1000点券,即7000 = 一款皮肤(6000) + 1000,也就是价值上等价了,点券没有凭空消失,皮肤也没有凭空出现。
- **持久性(durability)**原则,也就是说你的交易完成了,这个数据就应该永远存在,按理说不应该出现实例最后那种情况。
- 隔离性(isolation),这个体会应该不是很深刻,这个特性就是说,当你在购买的过程中,这时你的点券已经被扣除,但是皮肤还没有到你的账号,假设你在另一个地点还能登陆你的账号,并查看你的点券,通常情况你应该看到的还是7000点券。就是说,这个原子性的操作没有被全部执行完成并提交,这个原子性操作的结果对你来说通常是不可见的。为什么说是通常呢?这个就需要去看一下事务的隔离级别了!~~
精简:
- 原子性(Atomicity):要么都成功、要么都失败
- 一致性(Consistency):事务前后的数据完整性要保持一致
- 隔离性(Isolation):是多个用户并发访问数据库时,数据库为每一个用户开启的事务,不能被其他事务的操作数 据所干预
- 持久性(Durability):事务提交,事务一旦提交则不可逆,被持久化到数据库中!
2. spring 中的事务管理
- 声明式事务:AOP
- 编程式事务:需要在代码中,进行事务管理
思考:
为什么需要事务?
- 如果不配置事务,可能存在数据提交不一致的情况下;
- 如果我们不在Spring 中去配置声明式事务,我们就需要在代码中手动配置事务!
- 事务在项目的开发中十分重要,设计到数据的一致性和完整性问题,不容马虎!