Spring学习

最新推荐文章于 2024-11-06 19:12:03 发布
最新推荐文章于 2024-11-06 19:12:03 发布
阅读量485 收藏
点赞数
文章标签： spring 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43575301/article/details/131570624
版权

学习内容是跟着b站大佬遇见狂神说学习的，大家有兴趣建议去关注学习。

文章目录

1.Spring

1.1 简介Spring

Spring: 简化企业开发的复杂性，使现有技术更加容易使用，比如Servlet

官网：https://spring.io/projects/spring-framework#overview
官网下载地址：https://repo.spring.io/release/org/springframework/spring/
GitHub：https://github.com/spring-projects/spring-framework
org.springframework spring-webmvc 6.0.9 org.springframework spring-jdbc 6.0.9

1.2 优点

Spring是一个开源的免费的框架（容器）
Spring使一个轻量级的、非入侵的框架
控制反转（IOC）、面向切面编程（AOP）
支持事务的处理，对框架整合的支持

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

1.3 组成

在这里插入图片描述

1.4 拓展

现代化的Java开发，就是基于Spring的开发。
在这里插入图片描述

  • Spring Boot
    • 一个快速开发的脚手架
    • 基于SpringBoot可以快速开发单个微服务
    • 约定大于配置，和maven一样
  • Spring Cloud
    • Spring Cloud是基于SpringBoot实现

现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提需要掌握Spring和SpringMVC。

弊端：发展太久之后，违背原有的理念，配置十分繁琐。

2.IOC理论推导

1.UserDao接口

2.UserDaoImpl实现类

3.UserService业务接口

4.UserServiceImpl业务实现类

在之前的业务中，用户的需求可能会影响我们原来的代码，需要根据用户的需求去修改源代码，如果程序代码量十分大，修改一次成本会很贵！

我们使用一个Set接口实现类

 private UserDao userdao;
    //利用set实现动态值的注入
    public void setUserdao(UserDao userdao) {
        this.userdao = userdao;
    }

    public void getUser(){
        userdao.getUser();
    }
  • 之前程序是主动创建对象，控制权在程序员手上
  • 使用了Set后，程序不再拥有主动权，而是变成了被动的接收对象！

这种思想从本质上解决了问题，程序员buoy那个再去管理对象的创建了，系统的耦合性大大降低，可以更加关注在业务的实现上。

在这里插入图片描述

3.HelloSpring

  • Hello对象是谁创建的
    hello对象是由Spring创建的

  • Hello对象的属性是怎么设置的
    由Spring容器设置

这个过程就是控制反转

控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。

反转：程序本身不创建对象，而是变成被动的接受对象。

依赖注入：就是利用set方法注入的

IOC是一种编程思想，由主动的编程变成被动的接受。

可以通过newClassPathXmlApplicationContext去浏览一下底层源码。

目前不需要在程序中去改动了，要实现不同的操作吗，只需要在xml配置文件中进行修改，所谓的IOC，就是用Spring来创建、管理和装配。

4.IOC创建对象的方式

  • 1.使用无参构造创建对象，默认
  • 2.假设我们要使用有参构造创建对象
    - 下标赋值
<bean id="user" class="com.baidu.pojo.User">
            <constructor-arg index="0" value="狂神说Java"/>
        </bean>
  • 类型创建
<bean id="user" class="com.baidu.pojo.User">
            <constructor-arg type="java.lang.String" value="lihan"/>
        </bean>
  • 参数名
<bean id="user" class="com.baidu.pojo.User">
            <constructor-arg name="name" value="lihan"/>
</bean>

在配置文件加载的时候，容器中管理的对象就已经初始化了

5.Spring配置

5.1 别名

<!--    别名，如果添加了别名，就可以使用别名来获取这个对象-->
        <alias name="user" alias="userNew"/>
<!--    -->

5.2 Bean的配置

<!--    id:bean的唯一标识符，也就是相当于对象名
        class:bean对象所对应的全限定名：包名+类型
        name:也是别名，而且name也可以取多个别名
-->
        <bean id="userT" class="com.baidu.pojo.UserT" name="user2 u2,u3,u4">
            <property name="name" value="baidu"/>
        </bean>

5.2 import

一般适用于团队开发，可以将多个配置文件导入合并为一个

假设，现有项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，可以利用import将所有人的beans.xml合并为一个总的。

  • 张三
  • 李四
  • 王五
  • applicationContext.xml
<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml">

使用的时候直接用总的配置就可以了

6.依赖注入

6.1 构造器注入

看前

6.2 Set注入（重点）

  • 依赖注入：Set注入
    • 依赖：bean对象的创建依赖于容器
    • 注入：bean对象中的属性，由容器来注入

环境搭建：

1.复杂类型

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

2.真实测试对象

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

3.bean.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">

    <!--第一种，普通值注入，value-->
    <bean id="student" class="com.baidu.pojo.Student">
        <property name="name" value="lihan"/>
    </bean>
</beans>

4.测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getName());
    }
}

5.完善注册信息

<?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.baidu.pojo.Address">
        <property name="address" value="吉林"/>
    </bean>

    <bean id="student" class="com.baidu.pojo.Student">
        <!--第一种，普通值注入，value-->
        <property name="name" value="lihan"/>
        <!--第二种，Bean注入，ref-->
        <property name="address" ref="address"/>
        <!--数组-->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>三国演义</value>
                <value>水浒传</value>
            </array>
        </property>
        <!--List-->
        <property name="hobbies">
            <list>
                <value>抽烟</value>
                <value>喝酒</value>
                <value>烫头</value>
            </list>
        </property>
        <!--Map-->
        <property name="card">
            <map>
                <entry key="身份证" value="412721199805161434"/>
                <entry key="银行卡" value="6217002430044188986"/>
            </map>
        </property>
        <!--Set-->
        <property name="games">
            <set>
                <value>lol</value>
                <value>coc</value>
                <value>bob</value>
            </set>
        </property>
        <!--null-->
        <property name="wife">
            <null/>
        </property>
        <!--Properties-->
        <property name="info">
            <props>
                <prop key="学号">202108034</prop>
                <prop key="姓名">李涵</prop>
            </props>
        </property>
    </bean>
</beans>

6.3 拓展方式注入

我们可以使用p和c命名空间注入

使用：

<?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.baidu.pojo.User" p:name="李涵" p:age="25"/>
        <!--c命名空间，通过构造器注入：construct-args-->
        <bean id="user2" class="com.baidu.pojo.User" c:age="25" c:name="李涵"/>
</beans>

测试：

    @Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.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"

6.4 bean的作用域

在这里插入图片描述

  1. 单例模式（Spring默认机制）
<bean id="user2" class="com.baidu.pojo.User" c:age="25" c:name="李涵" scope="singleton"/>
  1. 原型模式：每次从容器get的时候。都会产生一个新对象
<bean id="user2" class="com.baidu.pojo.User" c:age="25" c:name="李涵" scope="prototype"/>
  1. 其余的request、session、application这些只能在web开发中使用。

7.Bean的自动装配

  • 自动装配是Spring满足bean依赖的一种方式。
  • Spring会在上下文中自动寻找，并自动给bean装配属性。

在Spring中有三种装配的方式

  1. 在xml中显式的配置
  2. 在Java中显式的配置
  3. 隐式的自动装配bean（重要）

7.1 测试

环境搭建

7.2 ByName自动装配

 <!--byName:会自动在容器上下文中查找，和自己对象set方法对应的值的bean id-->
 <bean id="people" class="com.baidu.pojo.People" autowire="byName">

7.3 ByType自动装配

<!--byType:会自动在容器上下文中查找，和自己对象属性相同的bean -->
<bean id="people" class="com.baidu.pojo.People" autowire="byType">

小结

  1. ByName：需要保证所有bean的id唯一，并且这恶鬼bean需要和自动注入的属性的set方法的值一致
  2. ByType：需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一致

7.4 使用注解实现自动装配

1.导入约束：context约束
2.配置注解的支持：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 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
        
        <context:annotation-config/>
</beans>

@Autowired
直接在属性上使用即可，也可以在set方法使用。
使用Autowired就可以不用编写Set方法，前提是自动装配的属性在IOC(Spring)容器中存在，且符合ByType。

@Resource注解

小结：@Resource和@Autowired的区别：

  • 都是用来自动装配的，都可以放在属性字段上
  • @Autowired通过ByType方式实现，而且必须要求这个对象存在！（常用）
  • @Resource默认通过ByName方式实现，如果找不到，则通过ByType实现，否则就报错！（常用）
  • 执行顺序不同：@Autowired 通过ByType的方式实现。@Resource默认通过ByName实现

8.使用注解开发

在Spring4之后，要使用注解开发，必须保证aop包的导入。

使用注解需要导入context约束，增加注解的支持。

  1. bean

2.属性注入

@Component
public class User {

    @Value("李涵")
    public String name;
    // 等价于<property name="name" value="李涵"/>
    public void setName(String name){
        this.name = name;
    }
}
  1. 衍生的注解
    @Component有几个衍生注解，在web开发中，会按照mvc三层架构分层
    - dao：【@Repository】
    - service:【@Service】
    - controller：【@Controller】
    这四个注解功能一样，都是代表将某个类注册到Spring中，装配Bean
  2. 自动装配
@Autowired：自动装配通过类型、名字，如果Autowired不能唯一自动装配属性，则需要通过@Qualifier（value="xxx"）
@Nullable: 字段标记了这个注解，说明这个字段可以未null
@Resource：自动装配通过名字、类型
  1. 作用域
@Component
@Scope("prototype")
public class User {

    @Value("李涵")
    public String name;
    // 等价于<property name="name" value="李涵"/>
    public void setName(String name){
        this.name = name;
    }
}

  • 小结
    xml和注解：

    • xml更加万能，适用于任何场合，维护简单方便
    • 注解不是自己类使用不了，维护相当复杂

xml与注解最佳实践：

  • xml用来管理bean
  • 注解只负责完成属性的注入
  • 在使用的过程中，只需要注意一个问题，必须让注解生效，就需要开启注解的支持
<!--指定要扫描的包，这个包下的注解就会生效-->
        <context:component-scan base-package="com.baidu.pojo"/>
        <context:annotation-config/>

9.使用Java的方式配置Spring

10.代理模式

10.1静态代理

角色分析：

  • 抽象角色：一般会使用接口或抽象类来实现
  • 真实角色：被代理的角色
  • 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
  • 客户：访问代理对象的人

代理步骤：
1.接口

//租房
public interface Rent {
    public void rent();
}

2.真实角色

//房东
public class Host implements Rent{
    public void rent(){
        System.out.println("房东要出租房子");
    }
}

3.代理角色

public class Porxy implements Rent{
    private Host host;

    public Porxy() {
    }
    public Porxy(Host host) {
        this.host = host;
    }
    public void rent(){
        seehouse();
        fare();
        host.rent();
    }
    //看房
    public void seehouse(){
        System.out.println("中介带你看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

4.客户端访问代理角色

public class Client {
    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
        //代理
        Porxy proxy = new Porxy(host);
        proxy.rent();
    }
}

代理模式的好处：

  • 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
  • 公共交给代理角色，实现业务的分工
  • 公共业务扩展的时候，方便集中管理

缺点：一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低

10.2 加深理解

在这里插入图片描述

10.3 动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类使动态生成的，不是直接写好的
  • 动态代理分为两大类：基于接口的和基于类的
    - 基于接口：JDK动态代理
    - 基于类 ：chlib
    - java字节码实现：javasist

需要了解两个类:Proxy:代理，InvocationHandler：调用处理程序

11.AOP

11.1 什么是AOP

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

11.2 AOP在Spring中的作用

提供声明式事务，允许用户自定义切面

  • 横切关注点：跨越应用程序多个模块的方法和功能，即使与业务逻辑无关的，仍需要关注的部分，就是横向关注点。如日志、安全、缓存、事务等等。。。
  • 切面：横向关注点被模块化的特殊对象，他是一个类
  • 通知：切面必须要完成的工作，他是类中的一个方法。
  • 目标：被通知对象
  • 代理：向目标对象应用通知之后创建的对象
  • 切入点：切面通知执行的“地点”的定义
  • 连接点：与切入点匹配的执行点

在这里插入图片描述
SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：
在这里插入图片描述
AOP在不改变原有代码的情况下，去增加新的功能

11.3 使用Spring实现AOP

使用AOP需要导入一个依赖包

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
</dependency>

方式一：使用Spring的API接口【抓哟SpringAPI接口实现】
方式二：自定义来实现AOP【主要是切面定义】
方式三：使用注解实现

12.整合Mybatis

12.1 mybatis

步骤：
1.导入相关jar包

  • junit
  • mybatis
  • mysql数据库
  • spring相关
  • aop织入
  • mybatis-spring【new】

2.编写配置文件
3.测试

12.2 Mybatis-spring

  1. 编写数据源配置
  2. sqlSessionFactory
  3. sqlSessionTemplate
  4. 需要给接口加实现类
  5. 将自己写的实现类，注入到Spring中

13.声明式事务

13.1 回顾事务

在这里插入图片描述

在这里插入图片描述

13.2 spring中的事务管理

在这里插入图片描述

无名之辈008
关注
spring 学习
08-04
由于提供的文件内容中存在大量重复的网址信息，并没有实际的教学内容或者相关知识点，我将从标题“spring 学习”出发，结合描述“通过搭建基本的工程，从中学习spring的原理”来详细阐述Spring框架的相关知识点。...
springboot 知识付费型网站
从入门到放弃
07-24 595
前段时间给一个客户开发了一套小型的知识付费型的网站系统，主要关注的是职场资料的共享，包含pc，手机端以及管理后台。 前后端分离，后端开发语言是java，数据库选择的是mysql。技术栈是springboot+mybatis+vuejs,前端的话就是html+jquery+layui。由于目前的体量没那么多，所以暂时没有考虑高并发，分布式等，后期看网站发展可能会进行相关调整。 先上几个效果图 1：pc端首页 2：文档在线预览效果 3：手机端 4：手...
spring学习.zip
11-01
本资源集合围绕"spring学习.zip"，提供了多本深入讲解Spring及其相关技术的电子书籍，旨在帮助读者深入理解和掌握Spring生态。 1. **《深入实践Spring Boot.陈韶健.pdf》**：这本书详细介绍了Spring Boot，它是...
spring学习
03-07
spring系统学习，解读spring，源码解读 spring系统学习，解读spring，源码解读 spring系统学习，解读spring，源码解读
spring学习资源
10-12
学习spring资源书籍，第三版讲解的很全面，包括springmvc的整合
SpEL（Spring Expression Language）入门指南
kersixy的博客
11-05 660
SpEL（Spring Expression Language）是 Spring 框架提供的一个强大的表达式语言，用于在运行时查询和操作对象图。它类似于 JSP EL（JavaServer Pages Expression Language）和 OGNL（Object-Graph Navigation Language），但在功能上更为丰富和强大。
SpringMVC入门详解
ning的博客
11-02 773
SpringMVC是一个基于Java的实现了MVC设计模式的Web框架，它通过将Web层进行模块化，使得Web应用程序的开发变得更加灵活和可维护。简化开发：通过注解的方式简化了配置，减少了代码量。强大的集成能力：可以很容易地与其他Spring模块集成。灵活的配置：支持零配置启动，也支持通过XML或Java配置进行详细配置。可重用性高：可以轻松地将一个项目中的代码重用到另一个项目中。
后端SpringBoot及vue proxyTable解决跨域
qq_42059717的博客
11-06 149
昨天上线项目遇到了一个奇怪的问题，本来服务实在腾讯云的轻量应用服务器的，但是迁移到一个香港的服务器之后就出现了各种各样的问题。Nginx 开启Https Springboot开启Https，先后出现了噔噔蹬蹬但是我其实已经部署了一个项目了的，那个用的proxyTable,新部署的这个用的是里边的env控制的。后来改成proxyTable就好了。
Spring中@Autowired@Resource和@Inject注解区别
2401_87333857的博客
11-06 354
同时，它默认是采用byType装配，当指定了1SR-330规范中的@Named注解之后，变成byName装配。它也可以出现在方法上，构造函数上和字段上但是需要注意的是:因为IRE无法决定构造方法注入的优先级，所以规范中规定类中只能有一个构造方法带@Inject注解。@Autowired:来源于spring框架自身默认是byType自动装配，当配合了@Qualifier注解之后，在没有指定name属性时是byType自动装配，当指定了name属性之后，采用byName方式自动装配。
【FL0013】基于SpringBoot和微信小程序的机电公司管理信息系统
Wo_Hui12138的博客
11-03 804
如今社会上各行各业，都喜欢用自己行业的专属软件工作，互联网发展到这个时候，人们已经发现离不开了互联网。新技术的产生，往往能解决一些老技术的弊端问题。因为传统机电公司管理信息系统信息管理难度大，容错率低，管理人员处理数据费工费时，所以专门为解决这个难题开发了一个机电公司管理信息系统管理系统，可以解决许多问题。 机电公司管理信息系统管理系统按照操作主体分为管理员和用户。管理员的功能包括字典管理、公告管理、考勤管理、客户管理、机电零件管理、机电零件订单管理、请假管理、机电设备管理、机电设备订单管理、用户管理、管理
在Springboot中更好的打印日志
nullPoninter的博客
11-02 260
1
Java项目：164 springboot校园资产管理
舒克日记的博客
11-04 380
人事管理系统分为管理员和用户两部分操作角色主要的功能有资产报废管理、用户管理、入库管理、资产借用管理、校园资产管理、个人信息管理。
SpringSession源码分析
lkr_lkr的博客
11-01 430
默认对常规Session的理解和使用，如何使用Set-Cookie。
spring 学习路线梳理(三)AOP
xiweihao的博客
11-02 923
通知类：定义一个类为切面类通知方法：需要在那个方法里面做增强需求描述：在每个实现方法执行前打印当前的系统时间连接点和切入点的理解： 在接口里面定义的方法是连接点，需要在哪些方法里面增强功能是切入点//定义实现类@Slf4j@Service@Autowired@Override!!@Override@Override@Component 将通知类交由spirng来管理@Aspect 将此类定义为切面类。
springboot-starter 整合feignClient
cqscf的博客
11-01 257
resource下建META-INF.spring.factories文件。
SpringBoot-配置文件
Vampire的博客
11-02 439
配置文件
Spring中的ConversionService，为Spring提供数据转换服务
weixin_42286658的博客
11-05 333
运行结果：上面的代码我们自定义了一个Date和String的Formatter，那么DefaultFormattingConversionService在进行Date和String之间的相互转换时，就会用我们自定义的Formatter 进行格式化和解析@Test@Override@Override});
SpringMVC项目转为SpringBoot项目
ning的博客
11-05 366
将Spring MVC项目转换为Spring Boot项目是一个提高项目现代化和开发效率的过程。通过上述步骤，我们可以将项目中的配置和依赖进行优化，利用Spring Boot的自动配置和微服务支持，使得项目更加简洁和易于维护。希望这篇文章能够帮助你顺利完成项目的迁移。版权声明：本博客内容为原创，转载请保留原文链接及作者信息。参考文章手把手教你将springmvc项目转为springboot。
配置文件中spring.cloud.consul.host属性
最新发布
weixin_42594143的博客
11-06 128
spring.cloud.consul.host属性是SpringCloudConsul项目中的一个关键配置项，它用于指定Consul服务器的主机地址。在SpringBoot应用程序中，spring.cloud.consul.host属性通常配置在application.yml或application.properties文件中。• 确保Consul服务可用：在配置spring.cloud.consul.host属性之前，需要确保Consul服务已经启动并运行在指定的主机和端口上。
spring学习教程
02-09
好的，下面是一些 Spring 学习教程的建议： 1. 官方文档：Spring 官方网站提供了详细的文档和教程，包括 Spring 基础知识、配置、集成、Web 应用开发等内容。 2. 在线课程：慕课网、极客时间等在线视频教程网站都...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值