Spring入门基础篇（一）

最新推荐文章于 2023-10-21 23:04:17 发布
最新推荐文章于 2023-10-21 23:04:17 发布
阅读量242 收藏
点赞数
分类专栏： Java框架 文章标签： Spring 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34474324/article/details/98943801
版权

Spring入门基础篇（一）

1. Spring地位

  1. 表述层

    SpringMVC

  2. 业务逻辑层

    Spring framework

  3. 数据持久层

    Mybatis/Hibernate，Springdata

2. Spring的简介

2.1 什么是Spring

  1. Spring产生于2003年，是一个开放源码的设计层面框架，解决的是业务逻辑层和其他各层的松耦合问题。
  2. Spring是一个分层的JavaSE/EE full-stack(一站式）轻量级开源框架。

2.2 Spring产生背景

  1. 创始人：rod johnson rod johnson的百度百科
  2. Spring官网
  3. Spring优点

  • 方便解耦合，简化开发。高内聚，低耦合。

     Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理

  • AOP编程的支持

      Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能

  • 声明式事务的支持

      只需要通过配置就可以完成对事务的管理，而无需手动编程

  • 方便程序的测试

      Spring对Junit4支持，可以通过注解方便的测试Spring程序

  • 方便集成各种优秀框架

     Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：MyBatis、Quartz等）的直接支持

  • 降低JavaEE API的使用难度

     Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

2.3 Spring的核心

  1. IOC 控制反转
  2. AOP 面向切面

2.4 Spring的体系结构

  1. 官方使用文档

在这里插入图片描述

  • core container 核心容器
    beans: 创建管理对象
    core：核心
    context：上下文，应用程序所处的环境（配置文件）
    SpEL: spring的EL表达式
    核心容器是创建项目必备的模块。

  • AOP：Spring的aop框架

  • aspects: aop框架

  • Data Access/Integration ：对Dao层的整合

    JDBC：整合jdbc，简化jdbc开发

    ORM：整合orm框架

    Transactions：事务的支持，TS是事务的关键字

    注： Dao 是 data access object

  • Web

    servlet：整合servlet

    web：对web层的支持，整合SpringMVC

  • Test：整合junit

3. Spring的入门案例

3.1 IOC

控制反转。

将对象创建和管理的权限反转给Spring容器。对象创建调用权的转移。

3.2 DI

依赖注入。

在运行阶段动态地向依赖赋值的过程。

3.3 IOC入门案例

  1. 创建java项目,导入jar包

    beans context core SpEL 必须的jar包 +comms-logging 日志管理

    所以，要做一个spring项目，至少需要4+1个jar包

  2. 首先通过new方法，实现一个项目。

  • pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.test</groupId>
    <artifactId>SpringDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>
    </dependencies>
</project>
  • UserDao.java 接口
package dao;

public interface UserDao {
    void addUser();
    void deleteUser();
}
  • UserDaoIpml
package dao.impl;

import dao.UserDao;

public class UserDaoIpml implements UserDao {

    public void addUser() {
        System.out.println("添加用户");
    }


    public void deleteUser() {
        System.out.println("删除用户");
    }
}
  • Test.java
package test;

import dao.UserDao;
import dao.impl.UserDaoIpml;

public class Test {
    
    @org.junit.Test
    public void test() {
        UserDao userDao = new UserDaoIpml();
        userDao.addUser();
        userDao.deleteUser();
    }
}
  • 运行结果
    在这里插入图片描述
    现在通过new创建对象。接下来希望Spring帮我创建对象，并从Spring的容器中将对象拿出来。

  1. 编写配置文件，上下文。一般情况下，叫做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:创建和管理一个对象
    id:bean的唯一标识
    class:类的全限定名称-->
    <bean id="userdao" class="dao.impl.UserDaoIpml"></bean>
</beans>

实际上，一个bean对应一个对象的管理与创建。

  1. 改变Test代码
package test;

import dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    @org.junit.Test
    public void test() {
       /*
        UserDao userDao = new UserDaoIpml();
        userDao.addUser();
        userDao.deleteUser();
        */

        //加载配置文件，获取Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //从容器中获取对象,第一个参数是id,第二个是类
        UserDao user=ac.getBean("userdao", UserDao.class);
        user.addUser();
        user.deleteUser();
    }
}

在这里插入图片描述

3.4 DI入门案例

在这里插入图片描述

  1. 创建一个UserService接口类
package servie;

public interface UserService {

    void addUser();
    void deleteUser();
}
  1. 创建一个UserService的接口类UserServiceImpl.java
package servie.impl;

import dao.UserDao;
import dao.impl.UserDaoIpml;
import servie.UserService;

public class UserServiceImpl implements UserService {
    
    //dao和service之间的耦合度比较高
    UserDao dao=new UserDaoIpml();

    public void addUser(){
        dao.addUser();
    }

    public void deleteUser(){
        dao.deleteUser();
    }
}

在这里插入图片描述
在这里插入图片描述
3. 修改测试类和xml

在这里插入图片描述

在这里插入图片描述

4. bean的实例化

  • 构造器创建
    在这里插入图片描述在这里插入图片描述

  • 静态工厂

    工厂就是创建对象的。里面所有的方法都是静态的。

    在这里插入图片描述
    在这里插入图片描述

  • 实例工厂

    里面的方法是非静态的。

    在这里插入图片描述

在这里插入图片描述

先有工厂对象，再去调用方法。

5. bean的作用域

默认情况下，使用单例模式管理对象。

利用scope配置作用域。
- singleton:单例
- prototype：多例
- request:每次请求创建一个对象
- session：每个会话中创建一个对象

6. bean的生命周期

6.1 初始化方法

在获取对象之前初始化

6.2 销毁方法

在容器关闭以后销毁对象

7. 使用xml方式bean的装配

  1. 手工装配
    • 设值注入：一个属性+set方法
    • 构造注入：属性+有参构造 constructor-arg

在这里插入图片描述

  1. 自动装配在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

8. 使用注解方式bean的装配

在这里插入图片描述

  1. @component 默认id为类名，首字母小写 <bean class="">
  2. @component(“id”) <bean id=" " class=" ">
    在这里插入图片描述
  3. @controller：web层
  4. @service：service层
  5. @repository：dao层

不确定是哪一层，可以直接使用@component

  1. @Autowired :按照类型注入
  2. @Autowired +@Qualifier(" "):按照名称注入
    在这里插入图片描述
    在这里插入图片描述
  3. @Resource(name=" "):按照名称注入

在这里插入图片描述

在这里插入图片描述

9. 整合junit

在这里插入图片描述

10. 代理

10.1 什么是代理

代理在真正对象处理之前和之后实现数据的预处理、过滤等操作。

解决代码重复问题。

10.2 代理模式

  1. 静态代理

    编译阶段，为目标类创建相应的代理类。

    缺点：

    需要为每个目标类创建一个代理类；
    为每个代理类中的方法添加代理方法，代理方法过多时重复。

在这里插入图片描述

  1. 动态代理

    运行阶段，动态为目标对象创建代理对象。

在这里插入图片描述

在这里插入图片描述

  • JDK动态代理

    需要编写接口和实现类。

    目前Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现。 其实现主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

import dynamicdao.UserDao;
import dynamicdao.impl.UserDaoImpl;
import org.springframework.test.context.ContextConfiguration;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.InvocationHandler;

@ContextConfiguration(locations = "classpath:ApplicationContext.xml")
public class Test {
    public static void main(String[] args) {
        //目标对象
        final UserDao dao = new UserDaoImpl();
        //为目标对象创建对象
        UserDao proxy = (UserDao) Proxy.newProxyInstance(dao.getClass().getClassLoader(), dao.getClass().getInterfaces(), new InvocationHandler() {

                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开始");
                        Object obj = method.invoke(dao, args);
                        return obj;
                    }
                }
        );
        proxy.addUser();
        proxy.deleteUser();

    }
}

  • cglib动态代理

    只需要实现类。

    创建目标对象的继承对象作为代理对象。

    导入jar包: asm.jar cglib.jar

    实际上，mybatis和spring.core中都有这两个jar包。

package cglibdao.Test;

import cglibdao.UserDaoImpl;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class Test {
    public static void main(final String[] args) {
        //目标对象
        final UserDaoImpl dao=new UserDaoImpl();
        //创建目标对象的继承对象作为代理对象
        //1.enhancer
        Enhancer enhancer=new Enhancer();
        //2.设置父类
        enhancer.setSuperclass(UserDaoImpl.class);
        //3.处理方法，即代理方法
        Callback callback=new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("开始");
                Object obj=method.invoke(dao);
                System.out.println("结束");
                return obj;
            }
        };
        enhancer.setCallback(callback);
        //4.创建代理对象
        UserDaoImpl proxy=(UserDaoImpl) enhancer.create();
        proxy.addUser();
        proxy.deleteUser();
    }
}

11. AOP

11.1 什么是AOP

面向切面编程，采用横向抽取的模式，在运行过程中，动态的向目标对象织入增强代码的思想。底层就采用动态代理。

11.2 AOP底层实现思想

jdk动态代理

cglib动态代理

有接口就调用jdk动态代理，无接口则用cglib动态代理。

11.3 应用场景

事务管理

性能测试

日志

11.4 AOP框架

spring aop
aspectj
jboss

11.5 专业术语介绍

target：目标对象，需要添加增强代码的类的对象
advice：通知，增强代码
jointpoint：连接点，可能增加增强代码的方法
pointcut：切入点，增加增强代码的方法
aspect：切面，切入点与增强代码之间形成的面。
weaving：织入，增强代码添加到切入点的过程。在这里插入图片描述

在这里插入图片描述

11.6 AOP开发

  1. 编写接口和实现类
  2. 编写增强代码
  3. 织入
    在这里插入图片描述

11.7 优秀博客

  1. Spring【AOP模块】就这么简单
  2. AOP概念理解
  3. 使用Spring进行面向切面编程

其他总结：

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

就是二二二二婷
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
一文学会Spring,Spring最简单的入门教程（万字好文）
毕业势必进大厂的博客
08-01 9052
spring教程
Spring入门篇
github_38596081的博客
01-04 330
第1章 概述 本章对课程的情况进行介绍，并介绍框架和Spring概况。 1-1 Spring入门课程简介 (05:56) 1-2 Spring概况 (09:39) 1-3 Spring框架 (04:24) 第2章 Spring IOC容器 介绍Spring IOC容器的基本概念和应用 2-1 IOC及Bean容器 (20:18) 容器中的对象就是Bean 使用Bea...
Spring入门，看这篇就够了
m0_54928777的博客
06-17 3424
一篇对Spring入门案例演示的文章，仅供正在学习Spring的小伙伴们参考哟！
Spring-全面详解（基础知识）
热门推荐
m0_63324772的博客
03-24 2万+
Spring-全面详解（基础知识）入门级 持续更新中 Spring5框架 内容介绍： 1.Spring概念 2.IOC容器 3.Aop 4.JDBCTEmplate 5.事物管理 6.Spring5新特性
Spring快速入门超详细讲解
南 阳 的博客
07-02 4264
在Spring框架规范中，所有由spring管理的对象都称之为Bean对象。Spring提供了以下多个注解，这些注解可以直接标注在java类上，将它们定义成Spring Bean。注解说明@Component该注解用于描述Spring中的Bean，它是一个泛化的概念，仅仅标识容器中的一 个组件（Bean），并且可以作用在任何层次，例如Service层、Dao层等，使用时只需将该注解标注在相应的类上即可。
Spring基础知识
m0_65260253的博客
06-29 931
Spring基础知识
【Spring学习笔记】1.入门
illusion
04-02 125
1.依赖 <!-- https://mvnrepository.com/artifact/org.springframework/spring-context --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring...
spring boot(一)之入门篇
08-30
总的来说，Spring Boot通过自动化配置和模块化设计，降低了Spring框架的入门门槛，提高了开发效率，使得开发者可以更专注于业务逻辑，而非基础架构的搭建。对于构建现代的、基于微服务的云原生应用，Spring Boot是不...
spring入门（一）
11-16
这篇教程将带你迈出Spring框架学习的第一步。 首先，我们要了解Spring的核心概念——依赖注入（DI）。在传统的Java程序中，对象通常自行创建其依赖项，这导致了代码紧密耦合，不易测试和维护。而Spring通过DI模式，...
spring boot入门篇demo+ppt
07-11
在"spring boot入门篇demo+ppt"中，我们可以期待学习以下核心知识点： 1. **Spring Boot基础知识**：了解Spring Boot的基本概念，包括其设计目标、主要特性以及与其他Spring框架的关系。 2. **起步依赖（Starter）...
SpringFramework中的AOP编程之入门篇
03-04
作为这个介绍Spring框架中的面向方面编程(Aspect-OrientedProgramming，AOP)的系列的第一部分，本文介绍了使您可以使用Spring中的面向方面特性进行快速开发的基础知识。使用跟踪和记录方面（面向方面领域的Hello...
spring 入门详解超
dark159735的博客
10-08 661
一.什么是spring 1.简介：Spring是一个开源的设计层面框架，解决了类与类之间的彻底解耦，它将面向接口的编程思想贯穿整个系统应用。 2.spring核心： IOC（Inverse of Control 控制反转）：将bean的创建权和引用权（DI（依赖注入））交给 spring容器。 AOP（Aspect Oriented Programming 面向切面编程）：对共同的连接点进行切面。 3.实际开发三层架构： 表现层（...
全网最详细的Spring入门教程
最新发布
YoYoYoWhatIsUp的博客
10-21 1464
其实spring的来源就是一个词语，完全解耦，为什么叫做完全解耦，还得从两个类的调用说起，接口1的实现类，我们叫做类1，接口2的实现类，我们叫做类2，现在我们有一个前提条件，就是，类2里面去new类1，且把类1的方法给到类2使用，我们现在形容类2和类1有依赖关系，也就是类2要依赖类1，那么如果出现一个境况也就是如果类1发生了改变，那么我们如何去使用类2，那我们在使用类2的时候就需要去改变类2里面的代码，一方面需要从新new一次类1，二方面需要把类2里面的方法对应新的类1的方法。我们采用set注入的方式。
Spring入门【总】
CODEING一场空的博客
06-26 532
org.springframework.orm.hibernate5.HibernateTransactionManager: 在hibernate环境下使用rg.springframework.jdbc.datasource.DataSourceTransactionManager: 在jdbcTemplate，mybatis(ibatis)环境下使用。
Spring笔记(1)：Spring基础
mingyuli的博客
10-22 871
·
Spring8大模块
SSSSSSch的博客
11-07 638
Spring8大模块
Spring 最全入门教程详解
lucky_fd的博客
07-04 6191
Spring 基础框架，可以视为Spring 基础设施，基本上任何其他 Spring 项目都是以 SpringFramework 为基础的。Spring 5 的模块结构图: lOC: Inversion of Control，翻译过来是反转控制。把对象创建和对象之间的调用过程，交给 Spring 进行管理Spring 的IOC 容器就是IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IOC容器。Spring 提供了IOC容器的两种实现方式：
Spring 基础知识
Lyndon的专栏
10-21 1099
Spring 基础知识
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

就是二二二二婷

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

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

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

打赏作者

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

抵扣说明：

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

余额充值