Spring学习笔记（全）持续完善...

最新推荐文章于 2024-07-20 20:04:43 发布

沐曦丶

最新推荐文章于 2024-07-20 20:04:43 发布

阅读量142

点赞数

分类专栏：框架文章标签： spring idea java

本文链接：https://blog.csdn.net/qisishuo/article/details/119427553

版权

框架专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Spring# 系列文章目录

提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
例如：第一章 Python 机器学习入门之pandas的使用

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

提示：以下是本篇文章正文内容，下面案例可供参考

一、pandas是什么？

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

二、使用步骤

1.引入库

代码如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

2.读入数据

代码如下（示例）：

data = pd.read_csv(
    'https://labfile.oss.aliyuncs.com/courses/1283/adult.data.csv')
print(data.head())

该处使用的url网络请求的数据。

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

Spring

1.1，简介

Spring：春天，给软件行业带来春天
2002年首次推出Spring框架的雏形，interdace21框架
Spring框架即一interface21为基础，经过重新设计，并不断丰富其内涵。于2004年3月24日发布1.0版本
Rod Johnson，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架。
SSH : Struct2 + Spring + Hibernate
SSM : Spring + SpringMVC + Mybatis
Spring文档：https://docs.spring.io/spring-framework/docs/current/reference/html/

核心配置maven依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-jdbc</artifactId>
		    <version>5.3.9</version>
		</dependency>

1.2，优点

Spring是一个开源的免费的框架（容器）
Spring是一个轻量级，非侵入式的框架！
控制反转（IOC），面向切面编程（AOP）
支持事务的处理，对框架整合的支持！
总结一句话：Spring是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架!

1.3 、组成

在这里插入图片描述

1.4 、拓展

现代化的Java开发！说白就是基于Spring的开发！

Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务。
- 约定大于配置。
Spring Cloud
- SpringCloud是基于SpringBoot实现的。
  因为大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要掌握Spring和SpringMVC! 承上启下的作用

弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“配置地狱”

2，IOC理论推导

UserDao 接口

public interface UserDao {
    void getUser();
}

UserDaoImpl实现类

public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.println("默认获取用户数据");
    }
}

UserService业务接口

public interface UserService {
    void getUser();
}

UserServiceImpl业务实现类

public class UserServiceImpl implements UserService {

    private UserDao userDao = new UserDaoImpl();

    public void getUser() {
        userDao.getUser();
    }
}

测试

public class MyTest {
    public static void main(String[] args) {

        //用户实际调用的是业务层，dao层他们不需要接触！
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }
}

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码！如果程序的代码量十分大，修改一次的成本价十分昂贵！
在这里插入图片描述

我们使用一个Set接口来实现，已经发生了革命性的变化

private UserDao userDao ;

    /**
     * 利用set进行动态实现的注入
     * @param userDao
     */
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

之前，程序是主动创建对象，控制权在程序员手上！
使用set注入后，程序不再具有主动性，而是变成了被动的接受对象！

这种思想，从本质上解决了问题，程序员在也不用管理对象的创建了！系统的耦合性大大降低，可以更加专注的在业务的实现上！
在这里插入图片描述

IOC本质

控制反转IOC（Inversion of Control），是一种设计思想， DI（依赖注入）是实现IoC的一种方法 ，也有人认为DI只是IOC的另一种说法。没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）。

3 、HelloSpring

3.1 、测试xml文件配置的Maven项目

编写实体类

@Data
public class Hello {
    private String str;

编写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
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    <!--使用Spring来创建对象，在Spring这些都称为Bean
    类型 变量名 = new 类型();
    Hello hello = new Hello();

    id = 变量名
    class = new的对象
    property 相当于给对象中的属性设置一个值！
        -->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

测试类

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象！
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //我们的对象现在都在Spring中的管理了，我们需要使用，直接去里面取出来就可以！
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

思考问题？

Hello对象是由谁创建的？
Hello对象是由Spring创建的
Hello对象的属性是怎样设置的
Hello对象的属性是有Spring容器设置的

这个过程就叫控制反转：
控制:谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。
反转：程序本身不创建对象，而变成被动的接收对象。
依赖注入：就是利用set方法来进行注入的。

IOC是一种编程思想，由主动的编程变成被动的接收。
可以通过new ClassPathXmlApplicationContext去浏览一下底层源码。

现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配！

4 、IOC创建对象的方式

默认使用无参构造进行创建！
假设我们要使用有参构造进行创建对象：(有如下三种情况)

下标赋值

<!--第一种方式：下标赋值    -->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="XXXJava"/>
</bean>

类型赋值（不建议使用）

<!--第二种方式：通过类型的创建，不建议使用    -->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg type="java.lang.String" value="lifa"/>
</bean>

参数名赋值

<!--第三种方式：直接通过参数名来设置    -->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="李发"/>
</bean>

5 、Spring配置

5.1 、别名

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

5.2 、Bean的配置

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

5.3 、import

这个import。一般用于团队开发使用，它可以将多个配置文件，导入合并为一个。
假设，现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！

张三
李四
王五
applicationContext.xml

<import resource="bean1.xml"/>
<import resource="bean2.xml"/>
<import resource="bean3.xml"/>

这样在使用的时候，直接使用总的配置文件applicationContext.xml即可！

6 、依赖注入

6.1 、构造器注入

前面已经介绍过，参考4、IOC创建对象的方式

6.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 Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
}

beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

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

测试类

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());
    }
}

完善注入信息

<bean id="address" class="com.kuang.pojo.Address">
        <property name="address" value="西安"/>
    </bean>

    <bean id="student" class="com.kuang.pojo.Student">
        <!--第一种：普通值注入，value        -->
        <property name="name" value="黑心白莲"/>

        <!--第二种：        -->
        <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="123456789987456321"/>
                <entry key="银行卡" value="359419496419481649"/>
            </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="driver">20191029</prop>
                <prop key="url">102.0913.524.4585</prop>
                <prop key="user">沐曦</prop>
                <prop key="password">123456</prop>
            </props>
        </property>

    </bean>

6.3 、拓展方式注入

我们可以只用 P 命名空间和 C 命名空间进行注入:

添加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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入，可以直接注入属性的值：property-->
    <bean id="user" class="com.qisishuo.pojo.User" p:name="沐曦" p:age="20"/>

    <!--c命名空间注入，通过构造器注入：constructor-args-->
    <bean id="user2" class="com.qisishuo.pojo.User" c:name="沐曦" c:age="22"/>

</beans>

测试：

@Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");

        User user = context.getBean("user",User.class);
        System.out.println(user);

        User user2 = context.getBean("user2",User.class);
        System.out.println(user2);
    }

注意点：P命名和C命名空间不能直接使用，需要导入xml的约束

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

7 、 Bean的自动装配

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

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

8 、使用注解开发

注解说明

@Autowired：自动装配通过类型，名字
- 如果Autowired不能唯一自动装配属性，则需要通过@Qualifier(value = “xxx”)
- 注解Autowired里的required属性默认为true
  如果显示的设置Autowired里的required属性默认为false
  说明这个对象可以为"null" ，否则不允许为 ”空“
@Nullable:字段标记了这个注解，说明这个字段可以为null
@Resource：自动装配通过名字，类型
@Component：组件，放在类上说明这个类被Spring管理了，就是been！
@Value(“xxx”) :放在属性声名或set方法上为该属性赋值！
@Scope(“singleton”):标注为单例模式

在Spring4之后，要使用注解开发，必须保证AOP的包导入了
在这里插入图片描述
使用注解导入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"       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></context:annotation-config>
</beans>
	<!--指定要扫描的包 ，这个包下的注解都会生效-->
    <context:component-scan base-package="com.qss.pojo"/>

bean
属性如何注入

/**
 * @Component  等价于  <bean id="user" class="com.qss.pojo.User"/>
 * @Value("沐曦")  等价于  <property name="name" value="沐曦"></property>
 */
@Component
public class User {
    @Value("沐曦")
    public String name = "沐曦" ;
}

衍生的注解
@Componend有几个衍生的注解，我们在web开发中，会按照mvc三层架构分层！

dao【@Repository】
service【@Service】
controller【@Controller】
这四个注解都是一样的，都是代表将某个类注册到Spring容器中，装配Been

自动装配置（参考：7 、 Bean的自动装配）
作用域
@Scope(“singleton”):标注为单例模式
小结

xml与注解

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

xml与注解的最佳实践：

xml用来管理bean ；
注解只负责属性的注入；
我们在使用的过程中，只需要注意一个问题，必须让注解生效，就需要开启注解的支持！

	<!--注解驱动支持的配置-->
    <context:annotation-config/>
    <!--指定要扫描的包 ，这个包下的注解都会生效-->
    <context:component-scan base-package="com.qss.pojo"/>

9 、使用java的方式配置Spring

1 、 Config类实现xml文件配置文件的作用

1 、 AnnotaionConfig

我们现在完全不使用xml配置了，全权交给Java来做！
JavaConfig是Spring的一个子项目，在Spring4之后，他成为了一个核心功能
在这里插入图片描述

1.2 、 Config类文件

配置文件

package com.qss.config;

import com.qss.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

/**
 * Created with Intellij IDEA
 *
 * @Auther: 齐思硕
 * @Date: 2021/08/09/17:23
 * @Description:
 */

/**
 * @Configuration代表这是一个配置类 ，就和我们之前看到的applicationContext.xml是一样的
 */
@Configuration   //这个也会交给Spring容器托管 ，注册到容器中 因为它一也是一个@componend
@Component("com.qss.pojo")   //扫描包
public class SpringConfig {

    /**
     * 注册一个Bean 就相当于我们之前写的一个bean标签
     * 这个方法的名字就相当于bean标签中的id属性
     * 这个方法的返回值 ， 就相当于bean标签中的class属性
     * @return
     */
    @Bean
    public User getUser(){
        return new User() ; //就是返回注入到bean的对象
    }
}

实体类

@Data
@Component   //这个注解的意思 ，说明这个类被spring接管了 ，注解到容器中
public class User {
    @Value("沐曦")  //属性注入值
    private String name ;
}

测试类

@Test
    public void test1(){

        /**
         * 如果完全使用了配置类去做 ，我们就只能通过 AnnotationConfig 上下文来获取容器
         */
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean("getUser" , User.class);
        System.out.println(user);
    }

这种纯java的配置方式，在SpringBoot中随处可见！

10 、代理模式

为什么学习代理模式？因为这就是SpriingAOP的底层！【Spring AOP和 SpringMVC】
代理模式的分类：

静态代理
动态代理

10.1 、静态代理

角色分析：

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

代码步骤

接口

public interface Rent {
    public void rent() ;
}

真实角色

//房东：实现租房的接口
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租房子...");
    }
}

代理角色

public class Proxy implements Rent{
    /**
     * 有一个原则：在代理时 ，少使用继承（会有很多局限性） ，多使用组合
     */
    private Host host ;

    /**
     * 无参构造
     */
    public Proxy() {
    }

    /**
     * 有参构造
     * @param host
     */
    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        fare();
        hetong();
    }
    
    /**
     * 中介特有：看房
     */
    public void seeHouse(){
        System.out.println("中介带看房...");
    }

    /**
     * 收中介费
     */
    public void fare(){
        System.out.println("收中介费...");
    }

    /**
     * 签租赁合同
     */
    public void hetong(){
        System.out.println("签合同...");
    }
}

客户端访问代理角色

public class Client {
    public static void main(String[] args) {
        /**
         * 房东要租房子
         */
        Host host = new Host();
       // host.rent();
        /**
         * 代理实现
         * 中介帮房东租房子 ，但是 ，代理对象会有一些附属操作
         */
        Proxy proxy = new Proxy(host);
        //你不用面对房东 ，直接找中介（代理对象）租房
        proxy.rent();
    }
}

代理模式的好处

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

缺点：

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

10.2 、加深静态代理的理解

沐曦丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring学习笔记（全）持续完善...

1.spring1.1简介Spring：春天，给软件行业带来春天欢迎使用Markdown编辑器你好！这是你第一次使用 Markdown编辑器所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。新的改变我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：全新的界面设计，将会带来全新的写作体验；在创作中心设置你喜爱的代码高亮
复制链接

扫一扫