spring基本使用

于 2024-04-25 11:10:35 发布
阅读量2.1k 收藏 40
点赞数 39
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65385133/article/details/138144849
版权
本文详细介绍了Spring框架中的InversionofControl(IoC)和DependencyInjection(DI)概念，包括Maven坐标引入Spring库，配置bean.xml，依赖属性注入，对象属性、数组和集合注入，构造器注入，以及Spring的注解使用。此外，还涵盖了AOP的面向切面编程，包括依赖导入、切面类编写、AOP支持和通知方法如前置通知、后置通知等。
摘要由CSDN通过智能技术生成

文章目录

1. ioc(Inversion of Control) | DI(Dependency Injection)

(1) maven坐标导包

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.22</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

(2) 编写配置文件bean.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">
       
</beans>

(3) 配置bean

在bean.xml配置文件的中配置bean

<bean id="stu" class="com.xjy.pojo.student">
</bean>

获取注入的对象:

    @Test
    public void test1(){
        ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        student stu = context.getBean(student.class);
        stu.setName("小明");
        stu.setAge(18);
        stu.setGender('男');
        System.out.println(stu);
    }

(4) 配置文件注入属性

 <bean id="stu" class="com.xjy.pojo.student">
        <property name="name" value="小慧慧"></property>
        <property name="age" value="18"></property>
        <property name="gender" value="女"></property>
    </bean>

获取对象:

    @Test
    public void test1(){
        ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        student stu = context.getBean(student.class);
        System.out.println(stu);
    }

2. DI(dependency injection) 依赖注入(setter)其他属性

(1) 对象属性注入

    <bean id="address" class="com.xjy.pojo.Address">
        <property name="province" value="云南"></property>
        <property name="city" value="昆明"></property>
        <property name="specificPosition" value="云南大学"></property>
    </bean>
    
    <bean id="stu" class="com.xjy.pojo.student">
        <!--对象属性注入-->
        <property name="address" ref="address"></property
    </bean>

(2) 数组属性输入

    <bean id="stu" class="com.xjy.pojo.student">
        <!--对象属性注入-->
        <property name="address" ref="address"></property>
        <!--数组属性数组-->
        <property name="grades">
            <array>
                <value>90</value>
                <value>70</value>
                <value>60</value>
            </array>
        </property>
    </bean>

查看结果:
在这里插入图片描述

(3) 集合属性注入

        <!--list属性注入-->
        <property name="course">
            <list>
                <value>语文</value>
                <value>数学</value>
                <value>英语</value>
            </list>
        </property>

(4) map集合注入

        <!-- map集合注入-->
        <property name="girlfriend">
            <map>
                <entry key="小诗诗" value="温柔可爱灵力大方"></entry>
            </map>
        </property>

(5) 构造器注入

声明构造方法:

    public student(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

声明bean(构造方法的参数需要和注入参数一一对应)

    <bean id="stu" class="com.xjy.pojo.student">
        <constructor-arg name="name" value="小诗诗"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="gender" value="女"></constructor-arg>
    </bean>

(6) 自动装配

    <bean id="address" class="com.xjy.pojo.Address">
        <property name="province" value="云南"></property>
        <property name="city" value="昆明"></property>
        <property name="specificPosition" value="安宁"></property>
     </bean>
     <!--这里配置了自动装配,会到ioc中找是否有对应类型的bean,常用还可按照名称装配(byname)-->
    <bean id="stu" class="com.xjy.pojo.student" autowire="byType">
        <!--对象属性注入-->
<!--        <property name="address" ref="address"></property>-->
  </bean>

3. 注解定义bean和依赖注入

(1) 开启注解扫描功能(配置文件)

<?xml version="1.0" encoding="UTF-8"?>
<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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启注解扫描-->
    <context:component-scan base-package="com.xjy.pojo"></context:component-scan>
    <!--加载配置文件使用${}属性占位符引用配置文件属性-->
 <context:property-placeholder location="jdbc.properties"/>
</beans>

(2) 声明bean和注入属性

@Component("address")   // 声明bean
@PropertySource("jdbc.properties") // 配置文件读取
public class Address {
    @Value("云南")   // 注入属性(可以使用${}引用配置文件属性)
    private String province;
    @Value("昆明")
    private String city;
    @Value("安宁")
    private String specificPosition;
}

(3) 获取bean

    @Test
    public void testAddressBean(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
        Address address = (Address) ctx.getBean("address");
        System.out.println(address);
    }

(4) 注解注入

	// 可以配合@Qualifier("名称")进行指定注入
    @Autowired
    private Address address;

查看注入是否成功:

    @Test
    public void testStudent(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        student bean = context.getBean(student.class);
        System.out.println(bean);
    }

(5) 配置类代替配置文件

编写配置类:

@Configuration		// 相当于配置文件
@ComponentScan("com.xjy.pojo")   //相当于包扫描
public class beanConfig {
    
}

通过配置文件获取:

    @Test
    public void test1(){
        ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(beanConfig.class);
        Address add = context.getBean(Address.class);
        System.out.println(add);
    }

(6) 第三方bean配置

在配置文件中配置bean:

    @Bean
    public ArrayList<String> stu(){
        return new ArrayList<>();
    }

4. AOP(Aspect Oriented Programming)面向切面编程

(1) 依赖导入

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.3.22</version>
    </dependency>
        <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.19</version>
    </dependency>

(2) 编写切面类

@Component      // 将该类声明为bean
@Aspect         // 声明该类为切面类
public class stuAspect {

    @After("execution(* com.xjy.pojo.student.*(..))")  // 后置通知,->切入点表达式表示插入方法
    public void getCurrent(JoinPoint joinPoint){
        Class<? extends JoinPoint> aClass = joinPoint.getClass();
        System.out.println(aClass+"执行结束");
    }
}

(3) 开启对aop的支持和注解扫描

@Configuration
@EnableAspectJAutoProxy     // 开启aop的支持
@ComponentScan({"com.xjy.pojo","com.xjy.aspect"})// 扫描注解包
public class beanConfig {
}

(4) 编写测试类测试

    @Test
    public void stuTest() throws InterruptedException {
        ApplicationContext context = new AnnotationConfigApplicationContext(beanConfig.class);
        student stu = context.getBean(student.class);
        stu.getSum();
    }

(5) 插入点表达式

execution(修饰符 返回值 方法全限定名(方法参数) 异常类型)

例如: (所有修饰符,所有返回值,com.examle.service中的所有类所有方法,所有参数)
execution(* com.example.service.*.*(..))

(6) 通知方法

前置通知Before

在目标方法执行前执行的通知。可以通过定义@Before注解的方法实现

后置通知(AfterReturning)

在目标方法成功执行后执行的通知。可以通过定义@AfterReturning注解的方法实现。

环绕通知(Around)

在目标方法执行前后都可以执行的通知，而且可以控制目标方法的执行。可以通过定义@Around注解的方法实现

@Component      // 将该类声明为bean
@Aspect         // 声明该类为切面类
public class stuAspect {
    @Pointcut("execution(* com.xjy.pojo.student.*(..))")
    public void cut(){}
    @Around("cut()")  // 前置通知,->切入点表达式表示插入方法
    public int getCurrent(ProceedingJoinPoint joinPoint) throws Throwable {
        long pre = System.currentTimeMillis();
        int result = (int) joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println(end-pre+"执行完毕");
        return result;
    }
}

测试运行:

    @Test
    public void stuTest() throws InterruptedException {
        ApplicationContext context = new AnnotationConfigApplicationContext(beanConfig.class);
        student stu = context.getBean(student.class);
        int sum = stu.getSum();
        System.out.println(sum);
    }

异常后通知(AfterThrowing)

在目标方法抛出异常时执行的通知。可以通过定义@AfterThrowing注解的方法实现

最终通知(AfterAdvice)

无论目标方法是否正常执行完成（包括正常返回或抛出异常），都会执行的通知。可以通过定义@After注解的方法实现。

夜深人静学 算法
关注
专栏目录
Spring基本使用
CodingYoo的博客
10-30 1240
一、Spring 框架概述 spring 是分层的JavaSE/EE应用轻量级开源框架，以IOC（inverse of control : 控制反转）和AOP(Aspect Oriented programing: 面向切面 编程)为内核。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4EiLzPSa-1604023954117)(C:\Users\lph\Desktop\笔记\Spring笔记\picture\001.png)] 1.2、Spring的优势 1.方便解耦，
深入理解Spring Redis的使用 (一) Spring Redis基本使用
weixin_57907028的博客
08-10 7846
关于spring redis框架的使用，网上的例子很多很多。但是在自己最近一段时间的使用中，发现这些教程都是入门教程，包括很多的使用方法，与spring redis丰富的api大相径庭，真是浪费了这么优秀的一个框架。这里，我们就对比之前对spring orm中对hibernate的使用，来理解使用spring redis的使用。（本文章不做redis基本命令使用的讲解） 1. Redis使用场景 Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库
spring创建项目
kunAUGUST的博客
07-26 212
ch01-hello-spring:使用的ioc,由spring创建对象 实现步骤： 1.创建maven项目 2.加入maven依赖 spring的依赖，版本5.1.9 junit依赖 3.创建类（接口和他的实现） 和没有使用框架一样，就是普通的类 4.创建spring需要使用的配置文件 声明类的信息，这些类由spring创建和管理 5.测试spring创建的类 <!--spring依赖--> <dependency> <groupId>org.sp
Spring的基本用法（一）
小伟的程序员历程---仅为个人学习需要
08-23 129
Spring是一个从实际开发中抽取出来的框架，因此它完成了大量开发中通用步骤，留给开发者的仅仅是与特定应用相关的部分，从而大大提高企业应用的开发效率。  Spring提供的是一个轻量级的解决方案，包括：基于依赖注入的核心机制，基于 AOP 的声明式事务管理，与多种持久层技术的整合，以及优秀的 MVC 框架等。 Spring的优点：低侵入式设计，代码的污染...
Spring的用法（详解）
单枪匹码
10-10 2711
1.Spring （1）Spring是什么？ 是一个轻量级的、用来简化企业级应用开发的开发框架。 注：a.简化开发：Spring对常用的api做了简化，比如，使用Spring jdbc来访问数据库，就不用再考虑如何获取链接、关闭链接、处理异常等等。 b.解耦：Spring容器（Spring框架的一个模块）帮我们管理对象（包括对象的创建及对象之间的依赖关系），这样一来，对象之间的耦合度会大大降低，...
spring的使用
qq_42894715的博客
03-07 248
什么是spring spring是javaweb开发的一个框架，为了解决企业应用开发的复杂性。 它有几个重要的特性 IoC DI 如何使用 IDEA中集合成了spring，可以直接在里面创建 控制翻转ioC(inversion of Control)
spring-boot-basic-auth：使用基本身份验证的安全Spring Boot REST API
02-04
在本文中，我们将深入探讨如何使用Spring Boot和Spring Security实现基于基本身份验证（Basic Authentication）的安全RESTful API。Spring Boot简化了创建独立、生产级别的基于Spring的应用程序，并且Spring ...
SpringBoot + Spring Security 基本使用及个性化登录配置详解
08-27
SpringBoot + Spring Security 基本使用及个性化登录配置详解 Spring Security 是一个功能强大且灵活的安全框架，它提供了认证、授权、攻击防护等功能。SpringBoot 是一个基于 Spring 框架的框架，它提供了很多便捷...
Spring Security基本配置方法解析
08-25
Spring Security基本配置方法解析 Spring Security是一个功能强大且可高度自定义的身份验证和访问控制框架，它是保护基于Spring的应用程序的事实上的标准。Spring Security是一个专注于为Java应用程序提供身份验证...
Spring的使用
SXTong_的博客
05-12 211
1、配置spring框架最基本的5个jar包 Spring有60多个jar包，要想使用首先要导入基本的jar包： Spring基础jar包4个：beans创建对象；core核心包；context英文输入；expression； spring日志包1个：common-longging-1.2 2．创建spring核心配置文件 ①在项目的src目录下创建application-context.xml文件: src~ 右键~ other~ xml file ~ application-context.xml
Spring的简单使用
一名码农的博客
07-26 1267
学习Spring的笔记
Spring使用手册
HongYu012的博客
02-21 650
一、序言 Spring 是 Spring 系列全家桶的核心与基础，熟练掌握 Spring 基础对后续学习 SpringBoot、SpringCloud、Spring Data 等大有裨益。 IoC 和 AOP 是 Spring 两大核心能力，玩转 Spring 高级特性，必须熟练掌握 AOP，理解 AOP 首先要理解动态代理。基于 JDK 的动态代理相对容易理解，但应用受限；CGlib 动态代理比较灵活，因此应用较为广泛。 二、事务 隔离性（Isolation）和传播性（Propagation）..
Spring 使用详解
weixin_57176230的博客
03-18 3491
引入spring及测试的依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.16</version> </dependency> <!--
Spring的使用（入门到熟练）---强势总结
最新发布
qq_48988285的博客
11-19 616
从Spring入门到熟练，非常详细的教程，包括IOC、DI、自动配置、AOP、动静态代理 CGLIB代理、DAO以及事务的讲解。
spring基本使用篇
weixin_45596022的博客
09-09 365
文章目录一，Spring概述1.spring是什么？2.spring的优势3.spring体系结构二，ioc的概念和作用1.程序的耦合和解耦2.解决耦合的思路3.工厂模式解耦代码：持久层服务层BeanFactory配置文件和测试类4.控制反转**Inversion Of Control**由解耦引发的问题三，使用spring的ioc解决程序的耦合1.基于xml形式的装配步骤代码2.基于xml装配ioc的细节1）BeanFactory 和 ApplicationContext 的区别2）Application
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值