一、Spring
SSH:Struct2 + Spring + Hibernate
SSM:SpringMVC + Spring + MyBatis!
配置文件
org.springframework
spring-webmvc
5.3.19
1.优点
-
Spring是一个开源的免费的框架(容器)!
-
Spring是一个轻量级的、非入侵式的框架!
-
控制反转(IOC),面向切面编程(AOP)!
-
支持事务的处理,对框架整合的支持!
总结一句话: Spring就是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架!
2.组成
3.拓展
- SpringBoot
- 一个快速开发的脚手架。
- 基于SpringBoot可以快速的开发单个微服务。
-
约定大于配置!
-
SpringCloud
- SpringCloud是基于SpringBoot实现的
因为现在大多数公司都在使用SpringBoot进行快速开发,学习SpringBoot的前提,需要完全掌握Spring及SpringMVC!承上启下的作用
弊端:配置繁琐
二、IOC理论推导
- UserDao接口
- UserDaolmpl实现类
- UserService 业务接口
-
UserServicelmpl 业务实现类
-
之前,程序是主动创建对象!控制权在程序猿手上!
- 使用了set注入后,程序不再具有主动性,而是变成了被动的接受对象!
这种思想,从本质上解决了问题,我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低~,可以更加专注的在业务的实现上!这是IOC的原型!
IOC本质
控制反转loC(Inversion of Control),是一种设计思想,DI(依赖注入)是实现loC的一种方法,也有人认为DI只是loC的另一种说法。没有
loC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后
将对象的创建转移给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了。
采用XML方式配置Bean的时候,Bean的定义信息是和实现分离的,而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解
的形式定义在实现类中,从而达到了零配置的目的。
控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是loC容器,其实现
方法是依赖注入(Dependency Injection,Dl)。
三、HelloSpring
接口
package com.Aaron.dao;
/**
* @Author: Alskaboo
* @Date: 2022-05-06 21:38
**/
public interface UserDao {
void getUser();
}
Impl
package com.Aaron.dao.Impl;
import com.Aaron.dao.UserDao;
/**
* @Author: Alskaboo
* @Date: 2022-05-06 21:39
**/
public class UserDaoImpl implements UserDao {
@Override
public void getUser() {
System.out.println("默认获取用户的数据");
}
}
package com.Aaron.dao.Impl;
import com.Aaron.dao.UserDao;
/**
* @Author: Alskaboo
* @Date: 2022-05-06 21:44
**/
public class UserDaoMysqlImpl implements UserDao {
@Override
public void getUser() {
System.out.println("Mysql获取用户的信息");
}
}
package com.Aaron.dao.Impl;
import com.Aaron.dao.UserDao;
/**
* @Author: Alskaboo
* @Date: 2022-05-06 21:45
**/
public class UserDaoOracleImpl implements UserDao {
@Override
public void getUser() {
System.out.println("Oracle获取用户的信息");
}
}
package com.Aaron.dao.Impl;
import com.Aaron.dao.UserDao;
/**
* @Author: Alskaboo
* @Date: 2022-05-06 21:57
**/
public class UserDaoSqlImpl implements UserDao {
@Override
public void getUser() {
System.out.println("Sql获取用户的信息");
}
}
Service接口:
package com.Aaron.service;
/**
* @Author: Alskaboo
* @Date: 2022-05-06 21:40
**/
public interface UserService {
void getUser();
}
Impl:
package com.Aaron.service.Impl;
import com.Aaron.dao.Impl.UserDaoImpl;
import com.Aaron.dao.Impl.UserDaoMysqlImpl;
import com.Aaron.dao.UserDao;
import com.Aaron.service.UserService;
/**
* @Author: Alskaboo
* @Date: 2022-05-06 21:41
**/
public class UserServiceImpl implements UserService {
private UserDao userDao;
//set进行动态值的注入!
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void getUser() {
userDao.getUser();
}
}
- Hello 对象是谁创建的?hello对象是由Spring创建的
Hello 对象的属性是怎么设置的?
- hello对象的属性是由Spring容器设置的,
这个过程就叫控制反转︰
控制:谁来控制对象的创建,传统应用程序的对象是由程序本身控制创建的,使用Spring后,对象是由Spring来创建的
反转:程序本身不创建对象,而变成被动的接收对象.依赖注入:就是利用set方法来进行注入的.
IOC是一种编程思想,由主动的编程变成被动的接收.
可以通过newClassPathXmlApplicationContext去浏览一下底层源码.
OK,到了现在,我们彻底不用再程序中去改动了,要实现不同的操作,只需要在xml配置文件中进行修改,所谓的loC,一句话搞定:对象由
Spring 来创建,管理,装配!
四、IOC创建对象的方式
- 使用无参构造创建对象,默认!
-
假设我们要使用有参构造创建对象。
-
下标赋值
- 类型
- 参数名
总结:在配置文件加载的时候,容器中管理的对象就已经初始化了!
五、Spring配置
1、别名
2、Bean的配置
3、import
这个import,一般用于团队开发使用,他可以将多个配置文件,导入合并为一个
六、DI依赖注入
1、构造器注入
前面已经写
2、Set注入【重点】
- 依赖注入:Set注入!
-
依赖: bean对象的创建依赖于容器!
-
注入: bean对象中的所有属性,由容器来注入!
环境搭建:
- 复杂类型
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
- 真实测试对象
public class Student {
private String name;
private String address;
private String[] books;
private List hobbys;
private Map card;
private Set games;
private String wife;
private Properties info;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String[] getBooks() {
return books;
}
public void setBooks(String[] books) {
this.books = books;
}
public List getHobbys() {
return hobbys;
}
public void setHobbys(List hobbys) {
this.hobbys = hobbys;
}
public Map getCard() {
return card;
}
public void setCard(Map card) {
this.card = card;
}
public Set getGames() {
return games;
}
public void setGames(Set 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 +
'}';
}
- applicationContent.xml
- 测试类
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.getName());
}
3、拓展注入
红楼梦
西游记
水浒传
三国演义
听歌
代码
电影
LOL
CS
COC
2020211891
男
import com.Aaron.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @Author: Alskaboo
* @Date: 2022-05-07 16:14
**/
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.toString());
/*
*Student{
* name='小菜',
* address=Address{address='重庆'},
* books=[红楼梦, 西游记, 水浒传, 三国演义],
* hobbys=[听歌, 代码, 电影],
* card={身份证=500231200103171452, 银行卡=2132161651310651651},
* games=[LOL, CS, COC],
* wife='贺建庆',
* info={学号=2020211891, 性别=男}}
*/
}
}
package com.Aaron.pojo;
/**
* @Author: Alskaboo
* @Date: 2022-05-07 17:07
**/
public class User {
private String name;
public int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public User() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试:
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("UserBean.xml");
User user = context.getBean("user2", User.class);
System.out.println(user);
}
注意点:p命名和c命名空间不能直接使用,需要导入xml约束!
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
4、bean的作用域
- 单例模式(Spring默认机制)
- 原型模式:每次从容器中get的时候,都会产生一个新对象!
- 其余的request、session、application这些只能在web开发中使用到!
七、Bean的自动装配
-
自动装配是Spring满足bean依赖一种方式!
-
Spring会在上下文中自动寻找,并自动给bean装配属性!
在Spring中有三种装配的方式
- 在xml中显示的配置
- 在java中显示配置
- 隐式的自动装配bean【重要】
1、测试
环境搭建:一个人两个宠物!
public class Cat {
public void shot(){
System.out.println("喵~");
}
}
public class Dog {
public void shot(){
System.out.println("汪~");
}
}
package com.Aaron.pojo;
/**
* @Author: Alskaboo
* @Date: 2022-05-07 21:59
**/
public class People {
private Cat cat;
private Dog dog;
private String name;
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "People{" +
"cat=" + cat +
", dog=" + dog +
", name='" + name + '\'' +
'}';
}
}
public class MyTest {
@Test
public void Test(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
People people = context.getBean("people", People.class);
people.getCat().shot();
people.getDog().shot();
}
}
2、ByName自动装配
3、ByType自动装配
小结:
-
byName的时候,需要保证所有bean的id唯一,并且这个bean需要和自动注入的属性的set方法的值一致!
-
byType的时候,需要保证所有bean的class唯一,并且这个bean需要和自动注入的属性的类型一致!
4、使用注解实现自动装配
- 导入约束:context
- 配置注解支持
@Autowired
直接在属性上使用即可!也可以在set方式上使用!
使用Autowired我们可以不用编写Set方法了,前提是你这个自动装配的属性在IOC (Spring)容器中存在,且符合名字byname!
如果@Autowired自动装配的环境比较复杂,自动装配无法通过一个注解【@Autowired】完成的时候、我们可以使用
@Qualifier(value=”xxx”)去配置@Autowired的使用,指定一个唯一的bean对象注入!
@Autowired
@Qualifier(value = "cat")
private Cat cat;
@Autowired
@Qualifier(value = "dog")
private Dog dog;
@Resource注解
@Resource(name = "cat")
private Cat cat;
@Resource(name = "dog")
private Dog dog;
小结:
@Resource和Autowired的区别:
- 都是用来自动装配的,都可以放在属性字段上
- @Autowired通过byType的方式实现,而且必须要求这个对象存在!【常用】
- @Resource默认通过byname的方式实现,如果找不到名字,则通过byType实现!如果两个都找不到的情况下,就报错!【常用】
- 执行顺序不同:@Autowired通过byType的方式实现
八、使用注解开发
在Spring4之后,要使用注解开发,必须要保证aop的包导入了
使用注解需要导入context约束,增加注解的支持!
- bean
- 属性如何注入
@Component
public class User {
@Value("小菜")
public String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
- 衍生的注解
@Component有几个衍生注解,我们在web开发中,会按照mvc三层架构分层!
- dao 【@Repository)
- service 【@Service】
- controller 【@Controller】
这四个注解功能都是一样的,都是代表将某个类注册到Spring中,装配Bean
- 自动装配置
-@Autowired:自动装配通过类型,名字。可不写set方法
如果Autowired不能唯一自动装配属性,则需要通过 @Qualifier(value = "XXX")
-@Qualifier(value = "cat"):定位
-@Resource:自动装配通过名字,类型。
-@Component: 组件,放在类上说明这个类被Spring管理了,就是bean
相当于
- 作用域
- 小结
xml与注解:
- xml更加万能,适用于任何场合!维护简单方便
- 注解不是自己类使用不了,维护相对复杂!
xml与注解最佳实践:
- xml用来管理bean;
- 注解只负责完成属性的注入;
- 我们在使用的过程中,只需要注意一个问题:必须让注解生效,就需要开启注解的支持
九、使用java的方式配置Spring
我们现在要完全不使用Spring的xml配置了,全权交给Java来做!
JavaConfig 是Spring的一个子项目,在Spring 4之后,它成为了一个核心功能!
实体类
@Component
public class User {
@Value("小菜")
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置文件
@Configuration
@ComponentScan("com.Aaron.pojo")
public class UserConfig {
//注册一个bean .就相当于我们之前写的一个bean标签
//这个方法的名字,就相当丁bean标签中的id属性
//这个方法的返回值,就相当丁bean标签中的cLass属性
@Bean
public User getUser() {
return new User();
}
}
测试类
public class MyTest {
@Test
public void test(){
ApplicationContext context = new AnnotationConfigApplicationContext(UserConfig.class);
User user = context.getBean("getUser", User.class);
System.out.println(user.getName());
}
}
十、代理模式
为什么要学习代理模式?因为这就是SpringAOP的底层!【SpringAOP 和SpringMVC】
代理模式的分类:
- 静态代理
- 动态代理
1、静态代理
角色分析:
- 抽象角色 :一般会使用接口或者抽象类来解决
- 真实角色︰被代理的角色
- 代理角色 : 代理真实角色,代理真实角色后,我们一般会做一些附属操作
- 客户 : 访问代理对象的人!
代码步骤:
- 接口
public interface Rent {
void rent();
}
- 真实角色
public class Host implements Rent{
@Override
public void rent() {
System.out.println("房东要出租房子");
}
}
- 代理角色
package com.Aaron.Demo01;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
/**
* @Author: Alskaboo
* @Date: 2022-05-08 16:56
**/
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Proxy implements Rent {
private Host host;
@Override
public void rent() {
host.rent();
seeHouse();
hetong();
fee();
}
public void seeHouse() {
System.out.println("中介带你看房");
}
public void hetong() {
System.out.println("签租赁合同");
}
public void fee() {
System.out.println("收中介费");
}
}
- 客户端访问代理角色
public class Client {
public static void main(String[] args) {
//房东
Host host = new Host();
//代理,加附属操作
Proxy proxy = new Proxy(host);
proxy.rent();
}
}
代理模式的好处:
- 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
-
公共也就就交给代理角色!实现了业务的分工!
-
公共业务发生扩展的时候,方便集中管理!
缺点:
- 一个真实角色就会产生一个代理角色;代码量会翻倍开发效率会变低
2、动态代理
- 动态代理和静态代理角色一样
-
动态代理的代理类是动态生成的,不是我们直接写好的!
-
动态代理分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口—JDK动态代理【我们在这里使用】
- 基于类: cglib
- java字节码实现 : javasist
需要了解两个类: Proxy:生成动态代理,InvocationHandler:调用处理程序并返回结果
package com.Aaron.Demo04;
import com.Aaron.Demo03.Rent;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @Author: Alskaboo
* @Date: 2022-05-08 18:46
**/
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成得到代理类
public Object getProxy() {
return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
//调用处理实例代码,并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
//动态代理的本质,就是使用反射机制的实现
Object result = method.invoke(target, args);
return result;
}
public void log(String msg) {
System.out.println("执行了" + msg + "方法");
}
}
优点:
- 一个动态代理类代理的是一个接口,一般就是对应的一类业务
- 一个动态代理类可以代理多个类,只要是实现了同一个接口即可!
十一、AOP
1、什么是AOP
AOP (Aspect Oriented Prograntg特基软件开发中的一个热点,也是Spring框架中的一个里安内合的理合的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
2、AOP在Spring中的作用
提供声明式事务;允许用户自定义切面
-
横切关注点:跨越应用程序多个模块的方法或功能。即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志,安全,缓存,事务等等…..
-
切面(ASPECT)︰横切关注点被模块化的特殊对象。即,它是一个类。
- 通知(Advice) :切面必须要完成的工作。即,它是类中的一个方法。
- 目标(Target)︰被通知对象。
- 代理(Proxy)︰向目标对象应用通知之后创建的对象。
- 切入点(PointCut) ︰切面通知执行的”地点”的定义。
- 连接点(JointPoint):与切入点匹配的执行点。
SpringAOP中,通过Advice定义横切逻辑,Spring中支持5种类型的Advice:
即Aop在不改变原有代码的情况下,去增加新的功能.
3、使用Spring实现AOP
导入依赖
org.aspectj
aspectjweaver
1.9.9.1
runtime
方式一:使用Spring的API接口【SpringAPI接口的实现】
log包
public class Log implements MethodBeforeAdvice {
//method: 要执行的目标对象的方法
//args: 参数
//target: 目标对象
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("[debug]"+target.getClass().getName()+"的"+method.getName()+"被执行了");
}
}
public class AfterLog implements AfterReturningAdvice {
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("[debug]执行了"+method.getName()+"方法,返回的结果"+returnValue);
}
}
service包
public interface UserService {
void add();
void delete();
void update();
void query();
}
public class UserServiceImpl implements UserService{
@Override
public void add() {
System.out.println("增加了一个用户");
}
@Override
public void delete() {
System.out.println("删除了一个用户");
}
@Override
public void update() {
System.out.println("修改了一个用户");
}
@Override
public void query() {
System.out.println("查询了一个用户");
}
}
xml
测试:
public class MyTest {
@Test
public void Test() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
//动态代理是接口
UserService userService = context.getBean("userService", UserService.class);
userService.delete();
}
}
方式二:自定义类【主要是切面定义】
方式三:使用注解实现
十二、整合MyBatis
步骤:
- 导入相关jar包
- junito
- mybatis
- mysql数据库
- spring相关的
- aop织入
- mybatis-spring 【new】
org.aspectj
aspectjweaver
1.9.9.1
org.springframework
spring-webmvc
5.3.19
org.springframework
spring-jdbc
5.3.19
mysql
mysql-connector-java
8.0.28
org.mybatis
mybatis-spring
2.0.7
- 编写配置文件
- 测试
1、回忆Mybatis
- 编写实体类
- 编写核心配置文件
- 编写接口
- 编写Mapper.xml
- 测试
2、Mybatis-spring
spring-dao.xml
十三、声明式事务
1、回顾事务
- 把一组业务当成一个业务来做,要么都成功,要么都失败!
-
事务在项目开发中,十分的重要,涉及到数据的一致性问题,不能马虎!
-
确保完整性和一致性;
事务ACID原则:
- 原子性
- 一致性
- 隔离性
- 多个业务可能操作同一个资源,防止数据损坏·
- 持久性
- 事务一旦提交,无论系统发生什么问题,结果都不会再被影响,被持久化的写到存储器中!
2、spring中的事务管理
- 声明式事务:AOP
- 编程式事务:需要再代码中,进行事务的管理
思考:
为什么需要事务?
- 如果不配置事务,可能存在数据提交不一致的情况下;
-
如果我们不在Spring中去配置声明式事务,我们就需要在代码中手动配置事务!
-
事务在项目的开发中十分重要,设计到数据的一致性和完整性问题,不容马虎!
Original: https://www.cnblogs.com/Alaskaboo/p/16305087.html
Author: Alaskaboo
Title: Spring
原创文章受到原创版权保护。转载请注明出处:https://www.johngo689.com/643701/
转载文章受原作者版权保护。转载请注明原作者出处!