Spring

于 2023-10-22 11:56:40 发布
阅读量171 收藏
点赞数 8
分类专栏： 框架学习 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80453393/article/details/133962713
版权

基本介绍

Spring是什么？

Spring是Spring团队开发的一款框架

这个框架的主要功能就是

  • 整合第三方框架
  • 为业务逻辑层提供事务支持
  • 还提供了WebMVC这个解决方案
  • 还提供了 DAO层的解决方案
  • JDBCTemplate

主要特性 DI（依赖注入）、IOC（控制反转）、AOP（面向切面编程）

七大模块

Core：核心模块 主要功能IOC、DI

AOP：面向切面编程

WebMVC：SpringMVC Controller层的解决方案（封装了servlet 简化请求与响应）

DAO：DAO层的解决方案 JDBCTemplate （类似于dbutils）

ORM：Object Relation Mapping 对象关系映射 用于整合第三方DAO层的框架（mybatis、hibernate）

Web：Spring对Web的支持

Context：上下文支持模块

代码编写

导包

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.1.3.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.3.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.1.3.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.3.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.1.3.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.1.3.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.26</version>
    <scope>provided</scope>
</dependency>

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

配置文件bean-base.xml

<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-4.0.xsd">
​
 <!-- 生成User类的实例 -->
 <bean id="user" class="com.qfedu.edu.pojo.User" />
</beans>

User类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
}

测试

public class Test {
    public static void main(String[] args) {
        //第一步：获取到初始化的容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-base.xml");

        //第二步：就可以实现实例的获取
        User user = (User) context.getBean("user");
        System.out.println(user);
    }
}

控制反转

理解：控制反转。

原来创建Java对象的时候是程序员自己创建；

学习完Spring之后，这个对象的创建可以交给Spring去管理、创建。

也就是说控制反转是指Spring控制了对象的创建，创建对象的权力反转了。

无参数对象

<!--    
        id                  实例的唯一标识
        class               生成实例信息的类路径
        name                实例名称
        scope="singleton"   单例 默认情况下是单例
        scope="prototype"   生成类的实例是多例
        init-method=""      对象放入IOC容器时 执行的方法
        destroy-method=""   对象在IOC容器中销毁时 执行的方法
        lazy-init="true"    懒加载 类被使用时生成对象放到IOC容器中
        在容器启动的时候 不生成对象放到IOC中
​
        IOC容器 就是一个ConcurrentHashMap集合
-->
<bean id="user" lazy-init="true" class="com.qfedu.edu.pojo.User"></bean>

带参数对象

<!--    创建有参数构造器的生成对象  通过参数下标赋值	-->
<!--  
 <bean id="user" class="com.qfedu.edu.pojo.User">
     <constructor-arg index="0" value="1"></constructor-arg>
     <constructor-arg index="1" value="buliyat"></constructor-arg>
     <constructor-arg index="2" value="123"></constructor-arg>
 </bean>
-->

<bean id="user" class="com.qfedu.edu.pojo.User">
    <constructor-arg name="id" value="1"></constructor-arg>
    <constructor-arg name="username" value="buliyat"></constructor-arg>
    <constructor-arg name="password" value="123"></constructor-arg>
</bean>

静态工厂

public class UserFactory {
    public static User getStaticUser() {
        return new User(1,"静态的用户名","静态的密码");
    }
}
<bean id="user" class="com.qfedu.edu.factory.UserFactory" factory-method="getStaticUser"></bean>

非静态工厂

public class UserFactory {
    public User getUserInstance() {
        return new User(1,"非静态的用户名","非静态的密码");
    }
}
<bean id="userFactory" class="com.qfedu.edu.factory.UserFactory"></bean>
<bean id="user" factory-bean="userFactory" factory-method="getUserInstance"></bean>

依赖注入

理解：依赖注入。A类引用了B类的方法，即A类依赖于B类。在开发时Controller调用Service，Service调用DAO或Mappe。我们认为：Controller依赖于Service，Service依赖于DAO。这就是依赖。注入的是IOC容器中的对象或者IOC容器中的具体值。

set注入

Service

public class UserService {
    private UserDAO userDAO;
    private String str;
    public void setStr(String str) {this.str = str;}
    public void setUserDAO(UserDAO userDAO) {this.userDAO = userDAO;}
    public void print() {userDAO.print();}
}

DAO

public class UserDAO {
    public void print(){
        System.out.println("-----userDAO执行了------");
    }
}

配置

<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-4.0.xsd">

    <bean id="userDAO" class="com.qfedu.edu.di.UserDAO" />
    <bean id="userService" class="com.qfedu.edu.di.UserService">
        <property name="userDAO" ref="userDAO" />
        <property name="str" value="xiaobobo" />
    </bean>
</beans>

测试

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-di.xml");

        UserService userService = context.getBean(UserService.class);
        userService.print();
    }
}

p标签注入

前提：注入位置必须写set方法 即p标签注入 实际上是set注入

配置

<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-4.0.xsd">

    <bean id="userDAO" class="com.qfedu.edu.di.UserDAO"></bean>
    <bean id="userService" class="com.qfedu.edu.di.UserService" p:userDAO-ref="userDAO"></bean>
</beans>

内部bean注入

内部bean注入也必须给定我们的set方法
即内部bean注入 也是set注入内部bean注入时
只给成员变量赋值 并没有将对象放入IOC容器中 很少使用

配置

<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-4.0.xsd">

    <bean id="userService" class="com.qfedu.edu.di.UserService">
        <property name="userDAO">
            <bean id="userDAO" class="com.qfedu.edu.di.UserDAO"></bean>
        </property>
    </bean>
</beans>

构造器注入

配置

<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-4.0.xsd">

    <bean id="userDAO" class="com.qfedu.edu.di.UserDAO"></bean>
    <bean id="userService" class="com.qfedu.edu.di.UserService">
        <constructor-arg name="userDAO" ref="userDAO"></constructor-arg>
    </bean>
</beans>

自动装配

<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-4.0.xsd"
       default-autowire="byType">
    <!--
      autowire："byName" ：通过名字进行装配
      autowire="byType"：这个表示的是通过类型去实现自动装配
 	-->

    <bean id="userDAO" class="com.qfedu.edu.di.UserDAO" />
    <bean id="userService" class="com.qfedu.edu.di.UserService" />
</beans>

注解实现

Service

/**
	将下面类的对象放到IOC容器中
	@Component 		一般用在其他的地方 下面两注解的父类
	@Service 		一般用在业务逻辑层
	@Repository 	一般用在DAO层
*/
@Component(value = "userService")// 设置该类在IOC中的名称 默认为类名的首写字母小写
@Scope(value = "singleton")   	// 设置 单例 或者 多例
@Lazy    						// 懒加载
public class UserService {
 @Resource   			    // 先名字 再类型
 @Autowired    				// 先类型 再名字
 private UserDAO userDAO;
 @PostConstruct     			// 对象放到IOC容器之后 要执行的方法
 public void init(){}
 @PreDestroy					// 对象在IOC容器中销毁时 要执行的方法
 public void destory(){}
 
 public void setUserDAO(UserDAO userDAO) {this.userDAO = userDAO;}
}

DAO

@Repository(value = "userDAO")
public class UserDAO {
    public void print(){}
}

面向切面

手动实现AOP

Service

@Service
public class UserService {
    public void update() {System.out.println("用户更新操作");}
    public void add() {System.out.println("添加操作");}
}

TransactionAop

@Component
public class TransactionAop {
    public void beginTransaction() {System.out.println("打开事务");}
    public void commitTransaction() {System.out.println("提交事务");}
    public void closeTransaction() {System.out.println("关闭事务");}
}

代理工厂

@Service
public class UserServiceProxyFactory implements MethodInterceptor {
    @Resource
    private  UserService userService;
    @Resource
    private TransactionAop transactionAop;
    public UserService getUserServiceProxy(){
        Enhancer enhancer=new Enhancer();
        enhancer.setCallback(this);
        enhancer.setSuperclass(UserService.class);
        return (UserService) enhancer.create();
    }

    public Object intercept(Object o, Method method,
                            Object[] objects, MethodProxy methodProxy) throws Throwable {
        transactionAop.beginTransaction();
        Object invoke = method.invoke(userService, objects);
        transactionAop.commitTransaction();
        transactionAop.closeTransaction();

        return invoke;
    }
}

配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 设置注解扫描的包 -->
    <context:component-scan base-package="com.qfedu.edu.aop.sx" />
</beans>

测试

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-aop-sx.xml");

        UserServiceProxyFactory bean = context.getBean(UserServiceProxyFactory.class);
        UserService userServiceProxy = bean.getUserServiceProxy();
        userServiceProxy.update();
    }
}

配置实现AOP

Service AOP类

public class Aop {
    public void before() {System.out.println("--------执行目标方法之前--------");}
    public void after() {System.out.println("--------执行目标方法之后--------");}
    public void afterThrowing(){System.out.println("-------抛出异常时执行--------");}
    public void afterReturn(){System.out.println("--------返回值之后执行--------");}
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable 
    {
        System.out.println("--------执行方法之前执行--------");
        Object proceed = proceedingJoinPoint.proceed();
        System.out.println("--------执行方法之后执行--------");
        return proceed;
    }
}

配置

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

 <bean id="userService" class="com.qfedu.edu.aop.config.UserService" />
 <bean id="aop" class="com.qfedu.edu.aop.config.Aop" />

 <aop:config>
     <aop:pointcut id="pt" expression="execution(* com.qfedu.edu.aop.config.*.*(..))" />
     <aop:aspect ref="aop">
         <aop:before method="before" pointcut-ref="pt" />
         <aop:after method="after" pointcut-ref="pt" />
         <aop:after-returning method="afterReturn" pointcut-ref="pt" />
         <aop:after-throwing method="afterThrowing" pointcut-ref="pt" />
         <aop:around method="around" pointcut-ref="pt" />
     </aop:aspect>
 </aop:config>

</beans>

测试

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-aop-config.xml");
        UserService bean = context.getBean(UserService.class);
        bean.add();
    }
}

注解实现AOP

Service

AOP类

@Aspect     // 当前类是切面类
@Component
public class Aop {
    // 指定切入点的表达式
    @Pointcut(value = "execution(* com.qfedu.edu.aop.annotation.UserService.*(..))")
    public void pt(){}
    @Before(value = "pt()")
    public void before() {System.out.println("--------执行目标方法之前--------");}
    @After(value = "pt()")
    public void after() {System.out.println("--------执行目标方法之后--------");}    
    @AfterThrowing(value = "pt()")
    public void afterThrowing(){System.out.println("-------抛出异常时执行--------");}
    @AfterReturning(value = "pt()")
    public void afterReturn(){System.out.println("--------返回值之后执行--------");}
    @Around(value = "pt()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable 
    {
        System.out.println("--------执行方法之前执行--------");
        Object proceed = proceedingJoinPoint.proceed();
        System.out.println("--------执行方法之后执行--------");
        return proceed;
    }
}

配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

    <!-- 指定注解扫描的包并打开Aop的自动代理 -->
    <context:component-scan base-package="com.qfedu.edu.aop.annotation" />
    <aop:aspectj-autoproxy />
</beans>

测试

Template

导包

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.3.RELEASE</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.40</version>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.9</version>
</dependency>

配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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-4.0.xsd">

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql:///cd-java-fy-2301" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>

    <!-- 配置操作数据库的对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- 配置Spring的注解扫描 -->
    <context:component-scan base-package="com.qfedu.edu.dao" />
</beans>

DAO

@Repository
public class UserDAO {
    @Resource
    private JdbcTemplate jdbcTemplate;

    public void add() {
        jdbcTemplate.update("insert into t_user(username,password) values(?,?)","xiaobobo","123");
    }

    public void update() {
        jdbcTemplate.update("update t_user set username=?","中国好");
    }
}

测试

public class Test01 {
    public static void main(String[] args){
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("classpath:bean-dao.xml");
        UserDAO userDAO = classPathXmlApplicationContext.getBean(UserDAO.class);
        userDAO.add();
    }
}

事务实现

BULIYAT
关注
专栏目录
2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
**My Coding Family**
04-20 8万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
spring6pdf详细讲解
09-18
spring6pdf详细讲解
Spring Boot面试题（2020最新版）
ThinkWon的博客
02-19 56万+
文章目录概述什么是 Spring Boot？Spring Boot 有哪些优点？Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？配置什么是 JavaConfig？Spring Boot 自动配置原理是什么？你如何理解 Spring Boot 配置加载顺序？什么是 YAML？YAML 配置的优势在哪里 ?Spring Boot 是否可以使用 XML 配置 ?spring boot......
【Spring】一个spring简单实例
一定要站在自己热爱的生活里闪闪发光
05-07 7万+
spring的基础知识就不讲了，直接上代码吧！ 为了方便大家创建文件，先把project的结构放在这 1.新建一个projec，本帖设置的名字为“project-hello”. 2. 新建一个package，这里取名为“com.company.project”. 3. 新建一个class，名为“Hello”。代码为： package com.company.project; public class Hello { private String name; pub.
史上最简单的 SpringCloud 教程 | 终章
热门推荐
方志朋的专栏
04-12 197万+
转载请标明出处： http://blog.csdn.net/forezp/article/details/70148833 本文出自方志朋的博客 错过了这一篇，你可能再也学不会 Spring Cloud 了！Spring Boot做为下一代 web 框架，Spring Cloud 作为最新最火的微服务的翘楚，你还有什么理由拒绝。赶快上船吧，老船长带你飞。终章不是最后一篇，它是一个...
Spring Boot源码解读与原理分析
herosunly的博客
10-17 5万+
最近机缘巧合之下，读到了LinkedBear编写的《Spring Boot源码解读与原理分析》这本书，本人花了一周的时间认真研读了一下这本书，真的是受益匪浅，特此推荐给大家，好书不容错过啊。 文章目录 1. 关于作者 2. 本书定位 3. 目标读者 4. 读后感受 5. 书籍特点 6. 总结与展望 LinkedBear是一名资深的Java开发工程师，他倾力研究Spring技术体系多年，对Spring、Spring Boot、MyBatis等框架有独到的见解，拥有丰富的框架体系实践经验和架构封装经验。
Spring中文文档下载
09-27
Spring中文文档
spring jar包
08-05
spring-aop-3.2.2.RELEASE.jar spring-beans-3.2.2.RELEASE.jar spring-context-3.2.2.RELEASE.jar spring-context-support-3.2.2.RELEASE.jar spring-core-3.2.2.RELEASE.jar spring-data-commons-1.5.0.RELEASE....
spring源码
10-16
springmvc的源码，采用典型的三层架构进行开发，最简单的增删改查，登陆、修改密码等
SpringBlade开发手册基础版
05-23
SpringBlade开发手册基础版
尚硅谷Spring笔记
04-11
尚硅谷Spring笔记
Spring例子
03-26
SpringmvcDemo、
Spring Security in Action
11-22
Spring Security in Action
spring-framework-5.3.20
06-13
spring-framework-5.3.20
spring文件夹
04-26
spring-aop-3.2.16.RELEASE、spring-aspects-3.2.16.RELEASE、spring-beans-3.2.16.RELEASE、spring-context-3.2.16.RELEASE、spring-core-3.2.16.RELEASE、spring-expression-3.2.16.RELEASE、spring-jdbc-3.2.16....
基于SpringCloud的快递驿站系统源码.zip
05-04
基于SpringCloud的快递驿站系统源码 基于SpringCloud的快递驿站系统源码 基于SpringCloud的快递驿站系统源码 基于SpringCloud的快递驿站系统源码 基于SpringCloud的快递驿站系统源码 基于SpringCloud的...
springcloud源码
08-13
优秀的spring cloud源码。本人亲测完美运行。详细部署方案请参照我的博客11。
Spring框架（spring-framework-5.2.6.RELEASE）的jar包
10-04
spring-framework-5.2.6.RELEASE/libs 目录下的所有jar包,也就是在使用Spring框架时所使用的所有jar包
springcloud实战
02-24
Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格...
spring saml
最新发布
12-08
Spring Security SAML是Spring Security的一个扩展，它提供了对基于SAML 1.1，2.0和WS-Federation的单点登录（SSO）的支持。它允许您将SAML身份验证和授权集成到Spring Security中，以便您可以使用Spring Security的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值