Spring学习笔记一

已于 2023-06-23 10:21:40 修改
阅读量505 收藏
点赞数
分类专栏： 后端相关 文章标签： spring 学习 笔记
于 2023-06-20 20:06:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lx00000025/article/details/131313559
版权

目录

一、Spring简介

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。
目前是JavaEE开发的灵魂框架。他可以简化JavaEE开发，可以非常方便整合其他框架，无侵入的进行功能增强。
Spring的核心就是 控制反转(IoC)和面向切面(AOP) 。

二、IOC控制反转

控制反转，之前对象的控制权在类手上，现在反转后到了Spring手上。

2.1入门案例

  1. 导入依赖
    导入SpringIOC相关依赖
            <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
  2. 编写配置文件
    applicationContext.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:配置一个bean对象，将对象交给IOC容器管理
        属性：
            id：bean的唯一标识，不能重复
            class：设置bean对象所对应的类型
    -->
    <bean id="helloworld" class="com.lx.pojo.helloWorld"></bean>
</beans>
  3. 创建容器从容器中获取对象并测试
    public class helloWorldTest {
    @Test
    public void testHelloWorld(){
        //获取IOC容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取IOC容器中的bean
        helloWorld helloworld = (helloWorld)ioc.getBean("helloworld");
        helloworld.sayHello();
    }
}

2.3 Bean的常用属性配置

  • id:bean的唯一标识，同一个Spring容器中不允许重复
  • class:全类名，用于反射创建对象
  • scope:scope主要有两个值：singleton和prototype
    如果设置为singleton则一个容器中只会有这个一个bean对象。默认容器创建的时候就会创建该对象。
    如果设置为prototype则一个容器中会有多个该bean对象。每次调用getBean方法获取时都会创建一个新对象。

三、DI依赖注入

依赖注入可以理解成IoC的一种应用场景，反转的是对象间依赖关系维护权。依赖注入就是IOC的具体实现

3.1 set方法注入

在要注入属性的bean标签中进行配置。前提是该类有提供属性对应的set方法。

public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private String[] hobby;
    private Clazz clazz;
    private Map<String,Teacher> map;
    public Student(){
        System.out.println("IOC通过无参构造创建对象");
    }

    public Student(Integer id, String name, Integer age, String sex) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String[] getHobby() {
        return hobby;
    }

    public void setHobby(String[] hobby) {
        this.hobby = hobby;
    }

    public Clazz getClazz() {
        return clazz;
    }

    public void setClazz(Clazz clazz) {
        this.clazz = clazz;
    }

    public Map<String, Teacher> getMap() {
        return map;
    }

    public void setMap(Map<String, Teacher> map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", hobby=" + Arrays.toString(hobby) +
                ", clazz=" + clazz +
                ", map=" + map +
                '}';
    }
}


    <bean id="studentTwo" class="com.lx.pojo.Student">
        <property name="id" value="001"></property>
        <property name="name" value="张三"></property>
        <property name="age" value="19"></property>
        <property name="sex" value="男"></property>
    </bean>

3.2 通过构造器注入

    <!--
        通过构造器赋值
        	顺序要和构造器的里参数的顺序一致
            name：指定属性名
            index：有参构造的参数索引
            type：属性类型
    -->
    <bean id="studentThree" class="com.lx.pojo.Student">
        <constructor-arg value="002"></constructor-arg>
        <constructor-arg value="李四"></constructor-arg>
        <constructor-arg value="30"></constructor-arg>
        <constructor-arg value="女" name="sex" index="3" type="java.lang.String"></constructor-arg>
    </bean>

3.3 复杂类型属性注入

配置如下：

<?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:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">

    <bean id="studentFour" class="com.lx.pojo.Student">
        <property name="id" value="001"></property>
<!--        <property name="name" value="&lt;张三&gt;"></property>-->
        <!--所有写在CDATA区中的字符都会被原样显示-->
        <property name="name">
            <value><![CDATA[<王五>]]></value>
        </property>
        <!--通过null标签给属性设置null-->
        <property name="age"><null/></property>
        <property name="sex" value="男"></property>
    </bean>
    <bean id="studentFive" class="com.lx.pojo.Student">
        <property name="id" value="004"></property>
        <property name="name" value="王五"></property>
        <property name="age" value="19"></property>
        <property name="sex" value="男"></property>
        <!--ref：引用IOC容器中某个bean的id-->
    <!--<property name="clazz" ref="clazzOne"></property>-->
        <!--级联的方式，要保证提前为clazz属性赋值或实例化-->
    <!--<property name="clazz.cid" value="005"></property>-->
    <!--<property name="clazz.cname" value="软件2班"></property>-->
        <!--内部bean-->
        <property name="clazz">
            <!--内部bean，只能在当前bean的内部使用，不能直接通过IOC容器获取-->
            <bean id="clazzInner" class="com.lx.pojo.Clazz">
                <property name="cid" value="006"></property>
                <property name="cname" value="大数据"></property>
            </bean>
        </property>
        <!--给数组类型赋值-->
        <property name="hobby">
            <array>
                <value>抽烟</value>
                <value>喝酒</value>
                <value>烫头</value>
            </array>
        </property>
        <!--给map类型赋值：也可以使用util:map标签赋值-->
        <property name="map">
            <map>
                <entry key="1" value-ref="teacherOne"></entry>
                <entry key="2" value-ref="teacherOne"></entry>
            </map>
        </property>
    </bean>
    <!--p命名空间注入-->
    <bean id="studentSix" class="com.lx.pojo.Student"
    p:id="1009" p:age="18" p:name="张三"></bean>

    <bean id="teacherOne" class="com.lx.pojo.Teacher">
        <property name="tid" value="1"></property>
        <property name="tname" value="张老师"></property>
    </bean>
    <bean id="clazzOne" class="com.lx.pojo.Clazz">
        <property name="cid" value="1"></property>
        <property name="cname" value="rj1class"></property>
    </bean>
    <bean id="clazzTwo" class="com.lx.pojo.Clazz">
        <property name="cid" value="1"></property>
        <property name="cname" value="rj1class"></property>
        <property name="students" ref="studentList"></property>
<!--        <property name="students">-->
<!--            <list>-->
<!--                <ref bean="studentTwo"></ref>-->
<!--                <ref bean="studentThree"></ref>-->
<!--                <ref bean="studentFour"></ref>-->
<!--            </list>-->
<!--        </property>-->
    </bean>
    <!--配置一个集合类型的bean，需要使用util的约束-->
    <util:list id="studentList">
        <ref bean="studentTwo"></ref>
        <ref bean="studentThree"></ref>
        <ref bean="studentFour"></ref>
    </util:list>
</beans>

四、Lombok

lombok作用 作用:简化用户创建实体对象(POJO)的过程,由插件自动的完成实体对象中常用方法的构建(get/set/toString/构造等)
1.导入依赖

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>

2.添加注解

@Data //根据属性生成set，get方法
@NoArgsConstructor //生成空参构造
@AllArgsConstructor //生成全参构造
public class Phone {
    private double price;
    private String name;
    private String password;
    private String path;

}

六、配置文件

6.1读取properties文件

我们可以让Spring读取properties文件中的key/value，然后使用其中的值。
在Spring配置文件中加入如下标签：指定要读取的文件的路径。

<context:property-placeholder location="classpath:filename.properties">

其中的classpath表示类加载路径下。
我们也会用到如下写法：classpath:*.properties 其中的 * 表示文件名任意。
注意：context命名空间的引入是否正确

6.2 使用配置文件中的值

    <!--引入jdbc.properties配置文件-->
    <context:property-placeholder location="jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

七、低频知识

7.1 bean的配置

7.1.1 name属性

  • 我们可以用name属性来给bean取名。获取的时候就可以使用这个名字来获取了

7.1.2 lazy-init

  • 可以控制bean的创建时间，如果设置为true就是在第一次获取该对象的时候才去创建。

7.1.3 init-method

  • 可以用来设置初始化方法，设置完后容器创建完对象就会自动帮我们调用对应的方法。
    @Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {

    private String name;
    private int id;
    private int age;
	//初始化方法
    public void init(){
        System.out.println("对学生对象进行初始化操作");
    }

}

    <bean class="com.lx.domain.Student" id="student" init-method="init"></bean>
    注意：配置的初始化方法只能是空参的。

7.1.4 destroy-method

  • 可以用来设置销毁之前调用的方法，设置完后容器销毁对象前就会自动帮我们调用对应的方法。
    @Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {

    private String name;
    private int id;
    private int age;

    public void init(){
        System.out.println("对学生对象进行初始化操作");
    }

    public void close(){
        System.out.println("对象销毁之前调用，用于释放资源");
    }
}

     <bean class="com.lx.domain.Student" id="student"  destroy-method="close"></bean>

7.1.5 factory-bean&factory-method

当我们需要让Spring容器使用工厂类来创建对象放入Spring容器的时候可以使用factory-bean和factory-method属性。
1.配置实例工厂创建对象

<!--创建实例工厂-->
    <bean class="com.lx.factory.CarFactory" id="carFactory"></bean>
    <!--使用实例工厂创建Car放入容器-->
    <!--factory-bean 用来指定使用哪个工厂对象-->
    <!--factory-method 用来指定使用哪个工厂方法-->
    <bean factory-bean="carFactory" factory-method="getCar" id="car"></bean>

测试

ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取car对象
Car c = (Car) app.getBean("car");
System.out.println(c);

2.配置静态工厂创建对象

<!--使用静态工厂创建Car放入容器-->
<bean class="com.lx.factory.CarStaticFactory" factory-method="getCar" id="car2"></bean>

3.也可以通过实现FactoryBean接口创建工厂

public class UserFactory implements FactoryBean<User> {
    @Override
    public User getObject() throws Exception {
        return new User();
    }


    @Override
    public Class<?> getObjectType() {
        return User.class;
    }
}

 <bean id="userFactory" class="com.lx.factory.UserFactory"></bean>

测试类

/*
* FactoryBean是一个接口，需要定义一个类实现该接口
* getObject():通过一个对象交给IOC容器管理
* getObjectType():设置所提供对象的类型
* isSingleton():是否单例
*
* */
public class UserFactoryTest {
    @Test
    public void testUserFactory(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-factory.xml");
        User user = context.getBean(User.class);
        System.out.println(user);
    }
}

八、生命周期

public class LifeCycleTest {
    /*
    * 生命周期：
    * 1.实例化
    * 2.依赖注入
    * 3.后置处理器postProcessBeforeInitialization：在初始化之前执行  (实现BeanPostProcessor接口)
    * 4.初始化 通过init-method指定初始方法
    * 5.后置处理器postProcessAfterInitialization：在初始化之后执行 (实现BeanPostProcessor接口)
    * 6.销毁 通过destroy-method指定销毁方法
    * */
    @Test
    public void test(){
        ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
        User user = context.getBean(User.class);
        System.out.println(user);
        context.close();
    }
}

    <!--
		init-method：指定初始方法
		destroy-method：指定销毁方法
	-->
    <bean id="user" class="com.lx.pojo.User" init-method="initMethod" destroy-method="destoryMethod">
        <property name="id" value="12"></property>
        <property name="username" value="admin"></property>
        <property name="password" value="123456"></property>
    </bean>
    <!--将BeanPostProcessor的实现类定义成bean，后置处理器才能生效-->
    <bean id="myBeanPostProcessor" class="com.lx.process.MyBeanPostProcessor"></bean>

后置处理器

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //在bean的生命周期初始化之前执行
        System.out.println("MyBeanPostProcessor--->后置处理器postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //在bean的生命周期初始化之后执行
        System.out.println("MyBeanPostProcessor--->后置处理器postProcessAfterInitialization");
        return bean;
    }
}
蓝朽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring学习笔记
一条游向寒江的鱼
08-30 431
spring基础学习
spring学习笔记1
03-16
spring学习笔记1
Spring学习笔记（一）Spring框架入门
weixin_72154059的博客
02-06 1525
1、 我们经常挂在口中的Spring指的是（Spring 框架）它是一个开源框架，有着活跃而庞大的社区。这就是它之所以能长久不衰的原因，Spring支持广泛的应用场景，它可以让Java企业级开发应用程序开更简单。2、Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE一站式（full-stack）轻量级开源框架。它最为核心的理念是IoC（控制反转）和AOP（面向切面编程），其中，IoC是Spring的基础，它支撑着Spring对JavaBean的管理功能；
Spring Cloud 学习笔记（1 / 3）
热门推荐
KISS
03-03 20万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
Spring学习笔记（一）
Europeqqq的博客
04-09 132
⭐。
Spring-尚硅谷-学习笔记
weixin_45581692的博客
10-10 6329
Spring框架是一个轻量级的开源的JavaEE框架。 Spring可以解决企业应用开发的复杂性。 Spring有两个核心部分：IOC和AOP IOC：控制反转，把创建对象的过程交给Spring AOP：面向切面，不修改源代码的情况下进行功能增强 Spring特点 方便解耦，简化开发 AOP编程支持 方便程序测试 方便和其他框架进行整合
Spring学习笔记之spring概述
yjnlovepy的博客
07-30 1257
Spring学习笔记之spring概述（没什么鸟用的文章）
【Spring】Spring学习笔记完整篇
MS_SONG的博客
08-09 2387
spring学习笔记完整版
Spring6学习笔记
weixin_43761434的博客
02-28 353
手写spring6代码地址 spring官网地址 spring重点笔记 Spring和SpringMVC的区别
SpringSecurity学习笔记
nuaa042216的博客
11-22 189
最近在学习SpringSecurity，把书中各个章节的内容融入自己曾经的一个项目中（基于SpringBoot+SpringSecurity+MyBatis+MySQL+VUE+Element），对各章节有了更深的体会，现在把学习的笔记记录下来，方便自己后面查找，也希望能帮助到有兴趣的同学。
Spring5学习笔记—整合MyBatis
分享思想，留下痕迹。
10-19 2万+
在我们之前的系列文章中，我们已经深入探讨了Spring5IOC和AOP，它们是Spring框架的基石。下面我们接着讨论开始讨论Spring5对于持久层框架MyBatis的整合，让我们一起开启新的的篇章吧。以上便是本文的全部内容，本人才疏学浅，文章有什么错误的地方，欢迎大佬们批评指正！我是Leo，一个在互联网行业的小白，立志成为更好的自己。如果你想了解更多关于Leo，可以关注公众号-程序员Leo，后面文章会首先同步至公众号。
Spring学习笔记1
08-03
在本篇Spring学习笔记中，我们将深入探讨Spring的几个关键知识点，包括其优点、AOP的实现原理以及声明式事务管理。 首先，Spring的优点在于它的轻量级特性，它不对现有类结构造成入侵，允许开发者专注于业务逻辑。...
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
Spring Cloud Alibaba学习笔记
03-18
Spring Cloud Alibaba学习笔记 内容简介： 1、微服务介绍 2、微服务环境搭建 3、Nacos Discovery--服务治理 4、Gateway--服务网关 5、Sleuth--链路追踪 6、Rocketmq--消息驱动 7、SMS--短信服务 8、Sentinel--服务...
javaSpring学习笔记
03-12
“Java Spring学习笔记”是一份宝贵的资源，专门为想要学习和掌握Java Spring框架的开发者而设计。这份学习笔记提供了详细而系统的教程和实践指南，帮助初学者快速入门，并带领已经有一定经验的开发者深入理解和应用...
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
小哇
07-23 379
zookeeper安装并成功运行。
SpringBoot启动命令过长
tiantiantbtb的博客
07-24 324
Error running 'DromaraApplication': Command line is too long. Shorten command line for DromaraApplication or also for Spring Boot default configuration?
Spring Security学习笔记（二）Spring Security认证和鉴权
最新发布
飞！！！的博客
07-24 677
用户认证的基础Filter，只有UsernamePasswordAuthenticationFilter这一个实现类。...//主要方法//先校验请求url与表单校验提交的url是否一致，不一致执行下一个Filter//一致的话就执行认证逻辑，一般默认的表单提交url是"/login"if (!} else {try {//实现类执行具体的认证逻辑return;//由子类实现具体的验证逻辑...
Java面试八股之Spring容器的启动流程
u012151345的博客
07-23 1023
在整个过程中，Spring遵循了IoC（控制反转）和DI（依赖注入）原则，确保Bean的创建、配置、组装和管理都在容器的统一控制之下，实现了松耦合和可扩展的软件架构。创建BeanDefinition：解析配置信息的过程中，Spring会为每个Bean生成对应的BeanDefinition对象，它包含了Bean的类型、构造方法参数、属性值、初始化方法、依赖关系、作用域、生命周期回调方法等所有相关信息。Spring容器的启动流程涉及一系列有序的操作，以确保容器正确初始化并准备好管理应用程序中的Bean。
spring 学习笔记
04-10
以下是关于Spring学习的一些笔记： 1. IoC（控制反转）：Spring通过IoC容器管理对象的创建和依赖关系的注入。通过配置文件或注解，将对象的创建和依赖关系的维护交给Spring容器来管理，降低了组件之间的耦合度。 2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

蓝朽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值