Spring学习笔记：1(初步认识概念)

最新推荐文章于 2022-08-01 18:11:01 发布
最新推荐文章于 2022-08-01 18:11:01 发布
阅读量207 收藏 1
点赞数 1
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45784666/article/details/107507211
版权

Spring的三大主要特征

spring主要特征有三个：控制反转（IOC），依赖注入（DI）和面向切面（AOP）。

IoC：Inverse of Control（控制反转）

1.对控制反转的理解

  • 传统方式：若要使用某个对象，需要自己去负责对象的创建，即new方式
  • 控制反转：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架
打个比喻：
  • 传统方式：相当于你自己去市场new 了一只鸡，不过是生鸡，要自己拔毛，去内脏，再上香料，酱油，烤制，经过各种工序之后，才可以食用。
  • 控制反转：相当于去肯德基(Spring)点了一只鸡，交到你手上的时候，已经五味俱全，你就只管吃就行了。

2.控制反转的主要形式有两种：依赖查找和依赖注入

  • 依赖查找：容器提供回调接口和上下文条件给组件。EJB和Apache Avalon 都使用这种方式。这样一来，组件就必须使用容器提供的API来查找资源和协作对象，仅有的控制反转只体现在那些回调方法上（也就是上面所说的 类型1）：容器将调用这些回调方法，从而让应用代码获得相关资源。
  • 依赖注入：组件不做定位查询，只提供普通的Java方法让容器去决定依赖关系。容器全权负责的组件的装配，它会把符合依赖关系的对象通过JavaBean属性或者构造函数传递给需要的对象。通过JavaBean属性注射依赖关系的做法称为设值方法注入(Setter Injection)；将依赖关系作为构造函数参数传入的做法称为构造器注入（Constructor Injection）。
一.创建Spring项目

在IDEA中创建Spring项目，编译器会自动导入相关的jar包，如下图：
在这里插入图片描述

二.在 Packge【com】下新建一个【Source】类：
package com;

public class Source {
    private String fruit;
    private String sugar;
    private String size;
    private String ice;

    public String getFruit() {
        return fruit;
    }

    public void setFruit(String fruit) {
        this.fruit = fruit;
    }

    public String getSugar() {
        return sugar;
    }

    public void setSugar(String sugar) {
        this.sugar = sugar;
    }

    public String getSize() {
        return size;
    }

    public void setSize(String size) {
        this.size = size;
    }

    public String getIce() {
        return ice;
    }

    public void setIce(String ice) {
        this.ice = ice;
    }
}
三.在 【src】 目录下新建一个 【applicationContext.xml】 文件，通过 xml 文件配置的方式装配我们的 bean
<?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 name="source" class="com.Source">
        <property name="fruit" value="橙子"/>
        <property name="sugar" value="正常糖"/>
        <property name="size" value="大杯"/>
        <property name="ice" value="多冰"/>
    </bean>
</beans>
四.在 Packge【test】下新建一个【TestSpring】类：
package test;

import com.Source;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Source source = (Source) context.getBean("source");
        System.out.println(source.getFruit());
        System.out.println(source.getSugar());
        System.out.println(source.getSize());
        System.out.println(source.getIce());
    }
}

代码结构图如下：
在这里插入图片描述
运行结果：
在这里插入图片描述

总结：
传统的方式：

通过new 关键字主动创建一个对象

IOC方式：

对象的生命周期由Spring来管理，直接从Spring那里去获取一个对象。 IOC是控制反转 (Inversion Of Control)的缩写，就像控制权从本来在自己手里，交给了Spring。

DI：Dependency Injection（依赖注入）

指 Spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象
上面也解释了这个概念，其实现方式有三种：属性注入（setter注入），构造器注入和自动装配。

一.属性注入

1.重新创建一个Spring项目，在src目录下创建com和test包
2.在com包下创建Students类和Classes类
package com;

public class Students {
    private String name;
    private String sex;
    private int age;
    private Classes classes;
    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

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

    public Classes getClasses() {
        return classes;
    }

    public void setClasses(Classes classes) {
        this.classes = classes;
    }
}

package com;

public class Classes {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
3.在src目录下创建applicationContext.xml文件，通过 xml 文件配置的方式装配我们的 bean
<?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 name="students" class="com.Students">
        <property name="name" value="小关"/>
        <property name="sex" value="男"/>
        <property name="age" value="19"/>
        <property name="classes" ref="classes"/>
    </bean>
    <bean name="classes" class="com.Classes">
        <property name="id" value="6"/>
        <property name="name" value="六班"/>
    </bean>
</beans>
4.在test包下创建测试类
package test;

import com.Students;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @org.junit.Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Students students = (Students) context.getBean("students");
        System.out.println(students.getName());
        System.out.println(students.getSex());
        System.out.println(students.getAge());
        System.out.println(students.getClasses().getId());
        System.out.println(students.getClasses().getName());
    }
}

运行结果如下图：
在这里插入图片描述
以上，就是属性注入。关键的是在类里面声明属性，写set方法，然后在xml里面配置bean和property的值。

二.构造器注入

构造器注入，就是在构造器里面注入依赖对象。其实跟属性注入差不多，先定义一个有参构造器，然后配置xml文件就行了。

1.在之前的基础上将Students类和Classes类进行修改
package com;

public class Students {
    private String name;
    private String sex;
    private int age;

    public Students(String name,String sex,int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    @Override
    public String toString() {
        return "{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}

package com;

public class Classes {
    private Students students;
    public Classes(Students students){
        this.students = students;
    }

    @Override
    public String toString() {
        return "Classes{" +
                "students=" + students +
                '}';
    }
}
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 name="classes" class="com.Classes">
        <constructor-arg ref="student"/>
    </bean>
    <bean name="student" class="com.Students">
        <constructor-arg value="小关"/>
        <constructor-arg value="男"/>
        <constructor-arg value="19"/>
    </bean>
</beans>
3.修改测试类
package test;

import com.Classes;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @org.junit.Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Classes classes = context.getBean(Classes.class);
        System.out.println(classes.toString());
    }
}

运行结果如下：
在这里插入图片描述

三.自动装配

…博主也不是很懂，以后再补上。

AOP：Aspect Oriented Program（面向切面）

AOP 即 Aspect Oriented Program 面向切面编程
如果说 IoC 是 Spring 的核心，那么面向切面编程就是 Spring 最为重要的功能之一了，在数据库事务中切面编程被广泛使用。

在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。

  • 所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务
  • 所谓的周边功能，比如性能统计，日志，事务管理等等

周边功能在 Spring 的面向切面编程AOP思想里，即被定义为切面。
在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 “编织” 在一起，这就叫AOP。

AOP 的目的：
AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

AOP 当中的概念：
转载于：https://blog.csdn.net/qukaiwei/article/details/50367761

  1. 通知（Advice）
    　 就是你想要的功能，也就是上面说的 安全，事物，日志等。你给先定义好把，然后在想用的地方用一下。
  2. 连接点（JoinPoint）
    　　这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行，不过那不是咱关注的，只要记住，和方法有关的前前后后（抛出异常），都是连接点。
  3. 切入点（Pointcut）
    　　上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有几十个连接点了对把，但是你并不想在所有方法附近都使用通知（使用叫织入，以后再说），你只想让其中的几个，在调用这几个方法之前，之后或者抛出异常时干点什么，那么就用切点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。
  4. 切面（Aspect）
    　　切面是通知和切入点的结合。现在发现了吧，没连接点什么事情，连接点就是为了让你好理解切点，搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过方法名中的before,after，around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。
  5. 引入（introduction）
    　　允许我们向现有的类添加新方法属性。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗
  6. 目标（target）
    　　引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，他可以在毫不知情的情况下，被咱们织入切面。而自己专注于业务本身的逻辑。
  7. 代理(proxy)
    　　怎么实现整套aop机制的，都是通过代理。
  8. 织入(weaving)
    　　把切面应用到目标对象来创建新的代理对象的过程。

关键就是：切点定义了哪些连接点会得到通知

小关同学喜欢吃汉堡
关注
专栏目录
14.SpringCloud学习笔记--Hystrix
java阳旭的博客
07-29 1290
Hystrix
2021 年最新基于 Spring Cloud 的微服务架构分析
SharingOfficer的博客
12-18 3173
Spring Cloud 是一个相对比较新的微服务框架，2016 年才推出 1.0 的 release 版本. 虽然 Spring Cloud 时间最短, 但是相比 Dubbo 等 RPC 框架, Spring Cloud 提供的全套的分布式系统解决方案。 Spring Cloud 是一系列框架的有序集合。它利用 Spring Boot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 Spring Boot 的开发风格做到一键.
Spring学习笔记--环境搭建和初步理解IOC
weixin_34272308的博客
10-30 79
Spring框架是一个轻量级的框架,不依赖容器就能够运行,像重量级的框架EJB框架就必须运行在JBoss等支持EJB的容器中,核心思想是IOC,AOP,Spring能够协同Struts,hibernate等其他众多的框架. 　　具体描述Spring: 　　　　1.轻量级:Spring是非侵入性的,基于Spring来开发的应用中的对象可以不依赖于SpringAPI. 　　　　2.依赖注入(DI) 　...
Spring初级学习笔记
weixin_33979363的博客
06-30 109
一、Spring简介 1.1 Spring是什么 Spring 是一个开源框架. Spring 为简化企业级应用开发而生. 使用 Spring 可以使简单的 JavaBean 实现以前只有 EJB 才能实现的功能. Spring 是一个 IOC(DI) 和 AOP 容器框架. 具体描述 Spring: 轻量级：Spring 是非侵入性的...
Spring初学（仅为自己学习笔记）
weixin_43914278的博客
04-20 132
本节重点 理解下面名词的概念： Spring Bean容器：存放对象的一种技术实现，对象的生命周期由容器进行统一管理 注：容器这个概念，在学框架的时候或者在学servlet以web为容器，都有触及这个知识点。 IOC Inversion of Control 控制反转 //IOC做了什么》生命周期不在由程序进行管理，包括new对象的创建，在方法结束之后把它进行销毁，这些本来...
Spring框架学习笔记1:spring介绍和初步搭建
code_feien的博客
06-06 260
​ 细节点： ​ 1、ApplicationContext就是IOC容器的接口，可以通过此对象获取容器中创建的对象 ​ 2、对象在Spring容器创建完成的时候就已经创建完成，不是需要用的时候才创建.此种情况满足的是单例模式。 ​ 3、对象在IOC容器中存储的时候默认 都是单例的，如果需要多例需要修改属性 scope=“prototype” ​ 4、创建对象给属性赋值的时候是通过set方法实现的，不能省略 public void setid(int id){ this.id = id; } ​ 5、对象
Spring的学习（一）——基本概念
有问题请发邮箱dengyifanlittle@163.com进行讨论
09-13 673
Spring是一个开源框架，为了解决企业应用开发的复杂性而创建的，但现在已经不止应用于企业应用。 可以帮助我们分离组件之间的依赖关系，所谓的组件之间的依赖关系，即应用程序当中对象和对象之间的依赖关系。 核心概念：核心概念可以参考我之前写的博客https://blog.csdn.net/qq_41061437/article/details/81257185 主要就是： IOC(控制反转)：...
全网最详细 Spring Cloud 入门总结
m0_67617557的博客
08-01 187
构建分布式系统不需要复杂和容易出错。SpringCloud为最常见的分布式系统模式提供了一种简单且易于接受的编程模型，帮助开发人员构建有弹性的、可靠的、协调的应用程序。SpringCloud构建于SpringBoot之上，使得开发者很容易入手并快速应用于生产中。官方果然官方，介绍都这么有板有眼的。有了Eureka，RestTemplate，Ribbon我们就可以愉快地进行服务间的调用了，但是使用RestTemplate还是不方便，我们每次都要进行这样的调用。...
Spark学习笔记——龟速更新。。
5akura's Blog
01-13 2268
文章目录Spark学习笔记第一章、基本认识与快速上手1.1、认识Spark1.2、对比Hadoop1.3、Spark组成基本介绍1.4、快速上手之WorldCount实现1.4.1、方式一（Scala类似集合操作实现）1.4.2、方式二(MR思维实现)1.4.3、方式三(Spark实现)第二章、环境搭建2.1、Local模式2.1.1、SparkShell命令行执行2.1.2、spark-sublime提交任务2.1.3、提交任务的参数说明2.2、Standalone模式2.2.1、配置改动与启动2.2.2
一篇搞定SpringCloud面试（两万字）
weixin_70730532的博客
06-24 314
本文来自一位非常卷的在校学生写的学习笔记，哎，这样太卷了！作为一个苦逼的在读大学生，又要面临半年一度的期末考试了，因为上课没听，我啥都不会，什么通信原理，单片机。。。饶了我吧！！！给你们看看我上课在干啥你就知道我为啥啥都不会了。上课笔记。。emmm，字比较丑😑。我还记得那是一堂英语课，老师不让用电子设备，我只能手写我这篇文章的思路。。。所以，冒着期末要挂科的风险👊，我也得把这篇文章写完，给大家分享知识，自己也能重新复习和认识一下 。总体架构官方果然官方，介绍都这么有板有眼的。我所理解的 就是微服务系统..
Spring学习一(spring概念和ioc入门)
qq_35654259的博客
08-21 1049
  Spring概念     Spring是一个开源轻量级框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组...
SpringMVC项目实战（HelloWorld）
盖世英雄来了
11-19 1782
springMVC框架的初步应用 1.创建一个maven项目，引入对应的jar包 引入要使用的jar包（注意，如果有红色没有引入的jar包，可以重新导入试一试） 点击项目 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0....
Spring入门了解和安装
ouyangkq666的博客
12-13 1204
一、 Spring框架概述 二、Spring特点 三、Spring5入门案例
java spring 注解 初始化对象_Java本地应用 使用spring 注解初始化
weixin_36382265的博客
02-25 133
service 类 及 接口ISample.java/****/package test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;/*** @ClassName: Test* @Des...
SpringBoot启动报org.springframework.boot.test.context、org.springframework.test.context.junit4不存在的解决方案
热门推荐
little prince，blue coder
08-02 2万+
问题描述： org.springframework.boot.test.context does not exist org.springframework.test.context.junit4.SpringJUnit4ClassRunner not exsit SpringBoot启动时报如上两个错误。   常规操作： 右键根项目—maven—update dependencies...
<property name="annotatedClasses"> 配置实体类，一次性就行
黄昏的大树
06-17 5016
<property name="annotatedClasses"> 配置实体类，一次性就行
JAVA----Spring入门教程（详细步骤）
weixin_43268636的博客
01-14 4425
本教程介绍如何在Spring 中创建一个简单的 Hello World 例子。 首先你要保证你eclipse安装了tomcat, 则要先去官网上下载一个tomcat tomcat官网，点击进入 我下载的是这个版本 安装教程 eclipse安装tomcat教程 接着要下载spring-framework,下载地址： spring-framework下载地址 我下载的版本是 解压到你想放的地址，在...
Spring包结构以及各个包之间引用关系说明
lntlky的专栏
09-04 524
Spring包结构以及各个包之间引用关系说明 Spring 包结构说明： spring.jar包含有完整发布的单个jar包。他包含有除spring-mock.jar之外的所有jar。原因是，spring-mock.jar只有在开发环境中才会用到，而且仅仅是作为一个辅助测试类存在。除了spring.jar，spring还包括13个独立的jar文件，他们各自包含这 sp
Spring学习笔记：Bootstrap框架详解
"这是一份关于Spring框架的资料笔记，主要涵盖了Spring的使用基础和一些相关的Web开发技术，如Bootstrap前端框架的介绍和应用。" 本文将深入探讨Spring框架的基础知识以及Bootstrap的常见功能，帮助读者更好地理解...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值