Spring5

Spring5 01、Spring简介

Spring的历史

Spring : 春天 —>给软件行业带来了春天

2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架

Rod Johnson是悉尼大学的博士，然而他的专业不是计算机，而是音乐学

Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网：Spring | Home

Spring的优点

Spring是一个开源免费的框架，容器（免费且开源是最重要的）

Spring是一个轻量级的，非入侵式的框架

控制反转IOC（Inversion of Control），面向切面AOP（Aspect Oriented Programming）

支持事务的处理，对框架的整合

一句话总结就是：Spring是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架。

02、控制反转（IOC）

IOC是Spring的核心内容

IOC是一种设计思想，DI(依赖注入)是实现IOC的一种方法

在没有IOC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，从而实现程序的解耦。个人认为所谓控制反转就是：获得依赖对象的方式反转了。（这里的第三方在Spring中就是IOC容器，所有需要的对象都交给IOC容器来创建，管理和装配，需要的时候只需get一下就可以了）

实现IOC可以使用XML配置，也可以使用注解，或者使用纯Java代码实现（新版本Spring官方推荐使用）。

先导入一下jar包（maven会导入与其相关的jar包，例如core，aop，beans等）

    org.springframework
    spring-webmvc
    5.3.14

03、依赖注入（DI）

依赖 : 创建Bean对象所依赖资源 .注入 : 由容器来注入Bean对象所依赖的资源 Set注入

被注入的属性一定要有set方法

创建Student对象（只展示了属性部分）

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List games;
    private Set hobbies;
    private Map card;
    private String wife;
    private Properties info;
}

创建Address对象（只展示了属性部分）

public class Address {
    private String city;
}

常量注入

Bean注入

数组注入

    
        西游记
        三国演义
        水浒传
        红楼梦
    

List注入

    
        王者
        和平精英
    

Set注入

    
        打游戏
        听歌
        不学习
    

Map注入

Null注入（null和字符串长度为0不是一回事啊）

Properties注入

    
        root
        123.com
    

构造器注入

被注入的属性一定要有构造方法

创建People对象（只展示了属性部分）

public class People {
    private String name;
    private Address address;
}

构造器参数下标注入

构造器参数名称注入（推荐使用名称注入）

构造器参数类型注入（尽量就不要用这个了）

p命名和c命名注入

p（properties），c（construction）命名空间可以实现直接在一行进行注入

一定要加加入头文件约束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

Bean的作用域

默认是singleton，也就是单例模式。

singleton：从容器中get到的相同名字的Bean对象是同一个对象

prototype：从容器中get到的相同名字的Bean对象不是同一个对象

在xml中同一个类可以写多个bean（名字不能相同），不同的bean，不是一个对象

04、自动装配 xml中配置

创建猫，狗，人类（只展示了属性部分）

被注入的属性一定要有set方法

public class Cat {
    public void shout(){
        System.out.println("喵喵喵~~");
    }
}

public class Dog {
    public void shout(){
        System.out.println("汪汪汪~~");
    }
}

public class People {
    private String name;
    private Cat cat;
    private Dog dog;
}

byName是根据set方法后的名称在容器中寻找是否有对应id的对象（命名规范很重要）

byType是根据所需类型在容器中寻找，如果有多个类型相同的，就寄了

使用注解

加上头文件约束，并开启注解支持

使用注解来实现自动装配可以没有set方法

xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
public class People {
    private String name;

    //Autowired先byType，如果有多个相同Type，再byName
    //required设置为false，表示目标对象可以不在IOC容器中，也就是可以为空，@Nullable注解也可以允许为空
    @Autowired(required = false)
    private Dog dog;

    //Qualifier直接找名字，必须和Autowired搭配使用
    @Autowired
    @Qualifier(value = "cat")
    private Cat cat;
}

05、使用注解开发

加上头文件约束，并开启注解支持，扫描指定包下的类，使得类中的注解生效

xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">

@Component("people")//相当于    ，若不写参数，则默认是people
@Scope("singleton") //相当于   定义bean的作用域配置
public class People {

    @Value("司南杓")//对属性进行注入，此时不需要set方法，如有set方法，也可以写在set方法上
    private String name;
}

@Component三个衍生注解

@Controller：web层@Service：service层@Repository：dao层

这些衍生注解仅仅是为了更好的进行分层，功能都是一样的

基于Java类进行配置

编写Dog类，MyConfig配置类

public class Dog {
    public void shout(){
        System.out.println("汪汪汪");
    }
}

@Configuration  //代表这是一个配置类
@import(MyConfig2.class)    //导入其他的配置类，就像xml配置里的import
public class MyConfig {
    @Bean   //方法名就是bean对象的id
    public Dog dog(){
        return new Dog();
    }
}

06、静态/动态代理模式

为什么要学习代理模式，因为AOP的底层机制就是动态代理！

静态代理

静态代理角色分析

抽象角色 : 一般使用接口或者抽象类来实现真实角色 : 被代理的角色代理角色 : 代理真实角色 ，代理真实角色后 , 一般会做一些附属的操作 .客户 : 使用代理角色来进行一些操作 .

RentHouse就是租房的抽象角色

public interface RentHouse {
    void rent();
}

Owner房东就是真实角色

public class Owner implements RentHouse{
    @Override
    public void rent() {
        System.out.println("房东出租房子");
    }
}

MyProxy中介公司就是代理角色

public class MyProxy implements RentHouse{
    private RentHouse rentHouse;
    public void setRentHouse(RentHouse rentHouse) {
        this.rentHouse = rentHouse;
    }

    @Override
    public void rent() {
        seeHouse();
        rentHouse.rent();
        contract();
    }
    private void seeHouse(){
        System.out.println("看房子");
    }

    private void contract(){
        System.out.println("签合同");
    }
}

Client就是客户

public class Client {
    @Test
    public void test(){
        MyProxy myProxy = new MyProxy();
        myProxy.setRentHouse(new Owner());
        myProxy.rent();
    }
}

代理模式就是用户这边不用操心别的事情，只需要找中介就可以，简化用户操作，所有的活都让中介来做被代理角色需要添加新的东西，不需要修改被代理角色内容，只需在中介处添加新功能即可核心就是，不改变原有代码，再加一层，来实现拓展业务缺点就是每一次代理，代码量就会扩大一倍 动态代理

动态代理的角色和静态代理的一样

动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的死代码

public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成得到代理类
    public Object getTargetProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    
    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    //处理代理实例，返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        contract();
        Object result = method.invoke(target, args);
        fee();
        return result;
    }

    private void fee(){
        System.out.println("收取房租费用");
    }
    private void seeHouse(){
        System.out.println("看房");
    }
    private void contract(){
        System.out.println("签合同");
    }
}

public class User {
    public static void main(String[] args) {
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        proxyInvocationHandler.setTarget(new Owner());
        RentHouse targetProxy = (RentHouse) proxyInvocationHandler.getTargetProxy();
        targetProxy.rent();
    }
}

07、面向切面（AOP）

什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

一句话总结就是： AOP在不改变原有代码的情况下 , 去增加新的功能

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …

切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。

通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。

目标（Target）：被通知对象。

代理（Proxy）：向目标对象应用通知之后创建的对象。

切入点（PointCut）：切面通知 执行的 “地点”的定义。

连接点（JointPoint）：与切入点匹配的执行点。

使用Spring API原生接口实现

先导入需要的jar包

    org.aspectj
    aspectjweaver
    1.9.8

导入约束

xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop 
https://www.springframework.org/schema/aop/spring-aop.xsd">

BeforeLog类

@Component
public class BeforeLog implements MethodBeforeAdvice {

    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法执行之前");
    }
}

AfterLog类

@Component
public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法执行完成，返回值是"+returnValue);
    }
}

UserService接口

public interface UserService {
    void add();
    void del();
}

UserServiceImpl类

@Component
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加操作");
    }

    @Override
    public void del() {
        System.out.println("删除操作");
    }
}

xml配置

测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //AOP代理的是接口，所以类型是接口类型
        UserService userServiceImpl = context.getBean("userServiceImpl", UserService.class);
        userServiceImpl.add();
    }
}

测试结果

自定义实现AOP（自定义切面）

DiyLog类

public class DiyLog {
    public void beforeExe(){
        System.out.println("操作执行前");
    }

    public void afterExe(){
        System.out.println("操作执行后");
    }
}

xml配置

测试结果

使用注解实现AOP

开启AOP注解支持

DiyLog类

@Component
@Aspect //标注这个类是一个切面
public class DiyLog {

    @Before("execution(* com.sinan.service.UserServiceImpl.*(..))")
    public void beforeExe(){
        System.out.println("操作执行前");
    }

    @After("execution(* com.sinan.service.UserServiceImpl.*(..))")
    public void afterExe(){
        System.out.println("操作执行后");
    }

    //在环绕增强中，可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.sinan.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint pj) throws Throwable {
        System.out.println("环绕前");

        Object proceed = pj.proceed();

        System.out.println("环绕后");
    }

    
}

测试结果

08、整合MyBatis

首先导入一堆包和添加头文件约束

	
        org.mybatis
        mybatis
        3.5.7
    
    
        mysql
        mysql-connector-java
        8.0.25
    
    
        org.mybatis
        mybatis-spring
        2.0.7
    
    
        org.aspectj
        aspectjweaver
        1.9.8
    
    
        org.springframework
        spring-jdbc
        5.3.13
    
    
        org.projectlombok
        lombok
        1.18.20
    



    
        
            src/main/java
            
                ***.xml
            
        
        
            src/main/resources
            
                **/*.*
            
        
    

User类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class User {
    private int id;
    private String name;
    private int age;
    private String sex;
}

UserMapper接口

public interface UserMapper {
    void selectUser();
    void delUser(int id);
    void insertUser(User user);
}

UserMapper.xml

    
        select * from user
    

    
        delete from user where id = #{id}
    

    
        insert into user values (#{id},#{name},#{age},#{sex})
    

 
UserMapperImlp类
 
@Component
public class UserMapperImpl implements UserMapper{

    @Autowired
    @Qualifier("sqlSessionTemplate")
    private SqlSessionTemplate sqlSessionTemplate;    //以前使用sqlSession，现在使用sqlSessionTemplate

    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    @Override
    public void selectUser() {
        sqlSessionTemplate.getMapper(UserMapper.class).selectUser();
    }

    @Override
    public void delUser(int id) {
        sqlSessionTemplate.getMapper(UserMapper.class).delUser(id);
    }

    @Override
    public void insertUser(User user) {
        sqlSessionTemplate.getMapper(UserMapper.class).insertUser(user);
    }
}
 
mybatis-spring.xml
 





    
    
    
    




    
    
    
    




    
    

 
这里注意了啊
 
 
在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。
  
SqlSessionFactory需要一个 DataSource（数据源）一个常用的属性是configLocation，它用来指定 MyBatis 的 XML 配置文件路径，另一个属性mapperLocations用来映射接口的xml配置文件
  
需要注意的是，这个配置文件并不需要是一个完整的 MyBatis 配置。确切地说，任何环境配置（），数据源（）和 MyBatis 的事务管理器（）都会被忽略。SqlSessionFactoryBean 会创建它自有的 MyBatis 环境配置（Environment），并按要求设置自定义环境的值。
  
SqlSessionTemplate 是 MyBatis-Spring 的核心。作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。
  
MyBatis-Spring提供了第二种方法来实现整合，通过继承SqlSessionDaoSupport类，然后就可以直接get到SqlSession，这样就跳过了管理SqlSessionTemplate 这一步
 
修改代码如下：
 
UserMapperImlp类
 
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper{

    //SqlSessionDaoSupport提供了getSqlSession方法来得到SqlSession
    //此时在bean中注入需要setSqlSessionFactory，或者注入SqlSessionTemplate
    //相当于加了一层，跳过了获取SqlSession的对象那一步

    @Override
    public List selectUser() {
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }

    @Override
    public void delUser(int id) {
        getSqlSession().getMapper(UserMapper.class).delUser(id);
    }

    @Override
    public void insertUser(User user) {
        getSqlSession().getMapper(UserMapper.class).insertUser(user);
    }
}
 
xml中UserMapperImlp的Bean对象需要注入SqlSessionFactory
 

    

 
09、声明式事务 
事务四个属性ACID
 
 
原子性（atomicity）
 
事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用
  
一致性（consistency）
 
一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中
  
隔离性（isolation）
 
可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏
  
持久性（durability）
 
事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中
  
Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。
 
编程式事务管理
 
 
将事务管理代码嵌到业务方法中来控制事务的提交和回滚
  
缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码
  
声明式事务管理
 
 
一般情况下比编程式事务好用。
  
将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
  
将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。
  
首先导入头文件约束
 
xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
 
配置xml
 

    





    
    
    
        
        
        
        
        
        
    




    
    

 
UserMapperImpl改造
 
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
    @Override
    public List selectUser() {
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.insertUser(new User(8,"梨花",20,"女"));
        mapper.delUser(8);
        return mapper.selectUser();
    }

    @Override
    public void delUser(int id) {
        getSqlSession().getMapper(UserMapper.class).delUser(id);
    }

    @Override
    public void insertUser(User user) {
        getSqlSession().getMapper(UserMapper.class).insertUser(user);
    }
}
 
将sql语法中的delete改为deletes
 
测试结果
 

 查看数据库，新人物并没有插入数据库，实现了事务。



转载请注明：文章转载自 www.mshxw.com
本文地址：https://www.mshxw.com/it/755629.html


   上一篇  前端ajax的application/x-www-form-urlencoded 参数提交
 
   下一篇  MyBatis使用PageHelper实现分页查询
  






Java相关栏目本月热门文章

  
1【Linux驱动开发】设备树详解（二）设备树语法详解
  
2别跟客户扯细节
  
3Springboot+RabbitMQ+ACK机制(生产方确认(全局、局部)、消费方确认)、知识盲区
  
4【Java】对象处理流（ObjectOutputStream和ObjectInputStream）
  
5【分页】常见两种SpringBoot项目中分页技巧
  
6一文带你搞懂OAuth2.0
  
7我要写整个中文互联网界最牛逼的JVM系列教程 | 「JVM与Java体系架构」章节：虚拟机与Java虚拟机介绍
  
8【Spring Cloud】新闻头条微服务项目：FreeMarker模板引擎实现文章静态页面生成
  
9JavaSE - 封装、static成员和内部类
  
10树莓派mjpg-streamer实现监控及拍照功能调试
  
11用c++写一个蓝屏代码
  
12从JDK8源码中看ArrayList和LinkedList的区别
  
13idea 1、报错java: 找不到符号 符号: 变量 log 2、转换成Maven项目
  
14在openwrt使用C语言增加ubus接口（包含C uci操作）
  
15Spring 解决循环依赖
  
16SpringMVC——基于MVC架构的Spring框架
  
17Andy‘s First Dictionary C++ STL set应用
  
18动态内存管理
  
19我的创作纪念日
  
20Docker自定义镜像-Dockerfile







热门相关搜索



路由器设置
木托盘
宝塔面板
儿童python教程
心情低落
朋友圈
vim
双一流学科
专升本
我的学校
日记学校
西点培训学校
汽修学校
情书
化妆学校
塔沟武校
异形模板
西南大学排名
最精辟人生短句
6步教你追回被骗的钱
南昌大学排名
清朝十二帝
北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
北京舞蹈学院排名
北京电影学院排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
北京邮电大学(宏福校区)排名
北京网络职业学院排名
北京大学医学部排名
河北科技大学排名
河北地质大学排名
河北体育学院排名







学习工具
代数计算器
三角函数
解析几何
立体几何


知识解答
教育知识
百科知识
生活知识
常识知识


写作必备
作文大全
作文素材
句子大全

实用范文


关于我们
关于我们
联系我们
网站地图


 
名师互学网交流群


名师互学网客服





名师互学网 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 






关于我们
文章归档
网站地图
联系我们
版权所有 (c)2021-2022 MSHXW.COM
ICP备案号：晋ICP备2021003244-6号