Spring 入门03

最新推荐文章于 2024-07-25 19:51:47 发布
最新推荐文章于 2024-07-25 19:51:47 发布
阅读量56 收藏
点赞数
分类专栏： spring 文章标签： spring java 后端
原文链接：https://blog.csdn.net/qq_16804847/article/details/122679215?spm=1001.2014.3001.5501
版权

1.Spring 层级代码结构

1.1 层级的划分

1. Controller 层 @Contorlller

2. Service 层 @Service

3. Mapper 层 @Repository

4.POJO根据数据表定义的实体类对象

1.1.1 编辑POJO

package com.jt.demo10.pojo;

import java.io.Serializable;
public class User implements Serializable {

    //1.属性都是私有的   方法是公有的 构造方法/get/set方法/toString
    //2.要求对象序列化   作用:1.保证数据按照正确的格式输出!!
    //                    2.在多线程条件下,共享数据必须序列化
    //3.POJO的对象一般都是用来实现数据的传递的.
    private Integer id;
    private String name;
    private Integer age;
    private String 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;
    }
}

1.1.2 编辑Mapper层

1.1.2.1编辑UserMapper接口

package com.jt.demo10.mapper;

import com.jt.demo10.pojo.User;

public interface UserMapper {
    //注意导包!!!
    void addUser(User user);
}

1.1.2.2 编辑UserMapper实现类

package com.jt.demo10.mapper;

import com.jt.demo10.pojo.User;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

//@Component
@Repository //Spring管理 key:userMapperImpl value:反射机制
public class UserMapperImpl implements UserMapper{

    @Override
    public void addUser(User user) {

        System.out.println("完成用户的入库操作:"+user.getName());
    }
}

1.1.3 编辑service层

1.1.3.1 编辑UserService 接口

package com.jt.demo10.service;

import com.jt.demo10.pojo.User;

public interface UserService {

    void addUser(User user);
}

1.1.3.2 编辑UserServiceImpl实现类

package com.jt.demo10.service;

import com.jt.demo10.mapper.UserMapper;
import com.jt.demo10.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

@Service //对象交给Spring容器管理 key:userServiceImpl value:对象
public class UserServiceImpl implements UserService {

    @Autowired //根据类型匹配
    private UserMapper userMapper;

    @Override
    public void addUser(User user) {

        userMapper.addUser(user);
    }
}

1.1.4 编辑控制层

package com.jt.demo10.controller;

import com.jt.demo10.pojo.User;
import com.jt.demo10.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    public void addUser(){
        User user = new User();
        user.setId(101);
        user.setName("春节愉快");
        user.setAge(2022);
        user.setSex("男");
        userService.addUser(user);
    }

}

1.1.5  编辑配置类

package com.jt.demo10.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.jt.demo10")
public class SpringConfig {
}

1.1.6 编辑测试类

package com.jt.demo10;

import com.jt.demo10.config.SpringConfig;
import com.jt.demo10.controller.UserController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestMVC {

    /**
     * 1.熟练掌握IOC/DI原理
     * 2.代码结构的嵌套 了解参数传递的规则.
     * 3.将原有的面向对象 进行了高级的抽象 练习
     * @param args
     */
    public static void main(String[] args) {
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        UserController userController = context.getBean(UserController.class);
        userController.addUser();
    }
}

1.1.7 层级代码调用流程图

 1.1.8 层级代码结构加载流程

        Map<UserMapperImpl,对象>
        <UserServiceImpl,对象>
        <UserController,对象>

1.用户执行main方法

2.spring容器开始执行ApplicationcContext

3.spring容器按照指定的规制加载配置类

4.根据配置类的注解开始完成包扫描@ComponentScan("com.jt.demo10")针对@Component注解有效;

5.如果先扫描到UserController,但是类中没有依赖项给UserService属性赋值,这线程先挂起来,继续往后扫描;

6.当程序解析到UserMapper,可以直接实例化对象交给spring容器管理;

7.当程序解析到UserService,根据依赖注入,给mapperService 属性注入Mapper的实现类,之后UserService类实例化成功

8.当程序加载完成之后,再次回到之前Controller对象挂起的地方,注入UserSevice 的实例对象,然后UserController实例化成功,至此Spring容器启动成功;

在这里插入图片描述

 

1.1.9 框架参数传递流程图

在这里插入图片描述

 2. Spring中Aop

2.1 Aop介绍

面向切面编程通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术;利用AOP可以对业务逻辑的各个部分进行隔离,从而使的业务逻辑各部分之间的耦合性降低;

AOP主要作用:在不修改原有代码的情况下对方法进行扩展

难点词语:

1.切面

2.预编译

3.动态代理

2.2 IOC-DI/AOP之间的区别

1.IOC-DI 利用第三方容器将对象统一管理,利用依赖注入为属性赋值,解决力对象和对象之间的耦合性问题;

升华:SpringMVC框架(对象),Mybatis框架(对象)类似的框架都可以交个Spring容器统一管理,解决了框架和框架之间的耦合性问题

2.3传统代码开发问题说明

2.3.1 创建项目

在这里插入图片描述

 

2.3.2清除多余的文件

在这里插入图片描述

 2.3.3 编辑测试案例

2.3.3.1 编辑UserService类

        1.定义接口

public interface UserService {

    void addUser();
}

2.3.3.2 编辑实现类

package com.jt.demo1.service;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{
    /**
     * 业务:要求 尽可能松耦合
     * 分析:
     *      1.UserService是业务处理类,其中addUser方法完成用户新增.
     *      2.其中事务的代码与业务代码紧紧的耦合在一起.
     *      3.如果事务的机制发生了变化,则所有的代码都将改变.耦合性高
     *      当前业务耦合性太高了!!!
     */
    @Override
    public void addUser() {
        System.out.println("创建事务对象2");
        System.out.println("事务开始2");
        System.out.println("新增用户成功!!!");
        System.out.println("事务提交2");
    }
}

2.4 动态代理

2.4.1动态代理的作用

总结:使用代理机制可以有效的降低代码的耦合性,将公共的代码/重复的代码,写到代理机制中,通过代理机制调用目标方法使的真实的业务被调用,可以有效的降低业务的耦合性

在这里插入图片描述

2.4.2 动态代理分类 

代理特点:使得代理对象和代理目标看起来一模一样;

2.4.2.1 动态代理-jdk动态代理

1.jdk动态代理是java jdk 提供的不需要引入额外的jar包

2.jdk动态代理要求代理对象实现和被代理对象相同的接口,必须有接口

3.jdk动态代理创建速度快,运行时稍慢

在这里插入图片描述

2.4.2.2 动态代理-CGLIB动态代理

1.CGLIB动态代理需要导入额外的jar包才能使用

2.CGLIB要求代理对象有无接口都可以,但是CGLIB代理对象是目标对象的子类.(继承) 

3.CGLIB创建代理对象时慢,但是运行期速度快

在这里插入图片描述

2.5 动态代理实现-jdk代理

2.5.1创建代理对象工具api 

1.动态代理创建代理对象的API ProxyInstance(loader,interfaces,h);

package com.jt.demo1.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//当前类是工具API,目的获取代理对象
public class JDKProxy {

    /**
     * 参数说明:
     * ClassLoader loader,  类加载器:将class加载到java运行机制中
     * Class<?>[] interfaces, 被代理者的接口数组  java可以多实现
     * InvocationHandler h  将代理对象扩展的内容写到处理器中
     * @param target
     * @return
     */
    public static Object getProxy(Object target){
        //1.获取目标对象的类加载器
        ClassLoader loader = target.getClass().getClassLoader();
        //2.获取接口数组
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //3.获取处理器对象
        InvocationHandler h = getInvocationHandler(target);
        //创建代理对象
        return Proxy.newProxyInstance(loader,interfaces,h);
    }

    //获取InvocationHandler对象
    public static InvocationHandler getInvocationHandler(Object target){
        //当代理对象执行业务操作时,通过InvocationHandler进行业务的扩展
        return new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("事务开始");
                //调用 让目标方法执行 target:目标对象!!!! 其它都是固定写法!!!
                Object result = method.invoke(target, args);
                System.out.println("事务提交");
                return result;
            }
        };
    }

}

2.5.2 动态代理实现方法扩展

package com.jt.demo1;

import com.jt.demo1.config.SpringConfig;
import com.jt.demo1.proxy.JDKProxy;
import com.jt.demo1.service.UserService;
import com.jt.demo1.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestTx{

    public static void main(String[] args) {
        ApplicationContext context =
            new AnnotationConfigApplicationContext(SpringConfig.class);
        //1.获取目标对象  userServiceImpl 接口UserSesrvice 实现类对象
        UserService target = context.getBean(UserService.class);
        //2.获取代理对象  实现了UserService接口
        UserService proxy = (UserService) JDKProxy.getProxy(target);
        proxy.addUser();
    }
}

2.6 关于动态代理的总结

为什么用动态代理:实现业务层的解耦;

规则:将公共的重复的代码写到代理对象中,业务层只专注于业务即可

byte2111
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring入门例子
04-14
Spring入门例子，只是实现了如何注入依赖，具体细节可以查看博客https://blog.csdn.net/qq_29924227/article/details/79942724
Spring入门经典
05-08
Beginning.Spring-Spring入门经典.pdf 学习 Spring 很好的入门书
spring入门
12-23
让我们从这个"spring入门"的描述出发，深入探讨Spring的核心概念和技术。 1. **依赖注入（Dependency Injection，DI）**：Spring 的核心特性之一是依赖注入，它允许开发者在运行时将对象之间的依赖关系进行管理。...
Spring入门学习笔记|Spring学习.pdf
10-17
Spring入门学习笔记，内容包括Spring介绍，Spring配置文件，Spring配置数据源，Spring的注解开发，Spring集成Junit，Spring的AOP，jdbcTemplate介绍，Spring控制事务流程，Spring集成web。
Vue 3 和 SpringBoot 实现文件分片上传示例
exlink2012的专栏
07-22 467
实现分片上传，并使用Spring Boot在后端保存文件。前端将文件分片并逐个上传到后端，后端接收到所有分片后再进行合并，最终保存为一个完整文件。
SpringMVC 控制层框架-下
woai3364的博客
07-20 1107
因此，在开发过程中，合理处理异常、避免异常产生、以及对异常进行有效的调试是非常重要的。如果张三负责的模块按照 A 方案处理异常，李四负责的模块按照 B 方案处理异常...各个模块处理异常的思路、代码、命名细节都不一样，那么就会让整个项目非常混乱。在Web 应用三层架构体系中，表述层负责接收浏览器提交的数据，业务逻辑层负责数据的处理。一个网站有 5、6个资源，其中有一个为登录资源，两个无需登录即可访问，另外三个需要登录后才能访问，如果不登录就访问那三个资源，需要拦截，并且提示登录后访问。
SpringBoot添加密码安全配置以及Jwt配置
qq_64468032的博客
07-25 713
然后修改之前的SecurityConfig配置类，里面的configure方法里面的.antMatchers里面追加的url是不需要验证就能进行使用的请求，比如登录注册等url请求的放开，需要的话可以一直追加。如果数据库中的密码没有加密，可以通过测试类将密码进行加密，然后用加密之后的字符串与数据库中的数据进行替换即可。通过以下操作可以直接从token中获取用户的信息，然后通过用户的信息进行验证并返回用户需要的信息。在没有配置的情况下，默认用户名为 user ，密码在控制台中查找（如下）。
SpringBoot启动命令过长
tiantiantbtb的博客
07-24 265
Error running 'DromaraApplication': Command line is too long. Shorten command line for DromaraApplication or also for Spring Boot default configuration?
spring-from表单
weixin_51482243的博客
07-22 881
2.Controller定义的接口指定consumes，produces对应的是客户端请求header的Content-Type，Accept；标记在方法上,对应接口的第2层地址；500是请求头Accept=text/plain,接口代码produces=MediaType.TEXT_PLAIN_VALUE,但代码响应是某类的对象;3.面试题/接口文档-要求请求参数是int类型，测试请求参数时还是字符串，但开发的代码需要类型转换，如@RequestParam(name="xx")Integer xx,
sed利用脚本处理文件
2201_75549363的博客
07-25 712
sed 命令是利用脚本来处理文本文件。它可以依照脚本的指令来处理、编辑文本文件。主要用来自动编 辑一个或多个文件、简化对文件的反复操作、编写转换程序等。
Spring通过工厂方法进行配置
学习笔记，人工智能，教程，技术分享！
07-21 469
工厂类CarStaticFactoryxml配置。
【OAuth2系列】集成微信小程序登录到 Spring Security OAuth 2.0
c18213590220的博客
07-21 1727
本文将详细介绍如何在 Spring Security OAuth 2.0 中扩展支持微信小程序登录，通过自定义授权方式实现无缝登录。
SpringBoot 测试Control接口方法
zhugedali_的博客
07-21 596
例如，如果 Controller 方法调用了服务层的某个方法来获取数据并进行处理，在单元测试中可以使用 Mockito 来模拟服务层方法的返回值，然后验证 Controller 方法基于这个模拟返回值所做出的后续处理是否正确。- 构建请求：可以设置请求的方法（如 GET 、 POST 、 PUT 、 DELETE 等），添加请求参数（通过 param() 方法）、请求头（通过 header() 方法），还可以设置请求体内容（对于 POST 、 PUT 等请求）。
Springboot @Validate @Valid 基于复杂嵌套对象的参数校验示例
nancheng_wx的博客
07-23 355
【代码】Springboot @Validate @Valid 基于复杂嵌套对象的参数校验示例。
SpringBoot-LangChain4j核心源码分析
Box_clf的博客
07-20 839
如果有对当前的aiService定义添加tool工具, 那么会tool工具调用对应的大模型function calling的api, 这样模型会知道何时才会去调用系统内部的工具类.注解用于导入其他的配置类，使得这些配置类中的bean定义可以被当前配置类所在的Spring容器中识别和管理。循环调用ai模型, 根据模型反馈需要调用的工具链并将结果告诉模型, 最后根据模型的response返回最终的执行结果给用户。 根据实际的配置信息构建对应的aiService的bean对象。
Spring AI (五) Message 消息
yuanchun的知识整理
07-24 933
上下文 角色设置
Spring Data Redis 报错 WRONGPASS invalid username-password pair问题解决
最新发布
BLF2
07-25 242
spring data redis版本：3.2.5redis server版本：社区版6.0.2。
Spring入门：构建首个应用
"Spring快速入门教程，通过一个简单的MyUsers应用程序介绍如何使用Spring、Struts和Hibernate构建三层架构的Web应用。本教程涵盖从下载所需工具到实现CRUD操作的全过程，强调Spring的声明式事务处理、依赖注入和持久...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值