spring注解方式 2022/08/22

已于 2022-08-23 15:57:24 修改
阅读量178 收藏
点赞数
分类专栏： # Spring 文章标签： spring java mybatis
于 2022-08-22 18:04:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liu_wen_wen/article/details/126470859
版权

spring注解方式

代码整体布局：

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

代码如下：

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>org.example</groupId>
    <artifactId>mybatis_0822_KTLX</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
    </dependencies>
</project>

spring-1.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="stu" class="com.test.Student" >
        <property name="name" value="张三"/>
        <property name="sex" value="男"/>
        <property name="age" value="20"/>
    </bean>
</beans>

Student:

package com.test;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//@Component:用于告诉spring，当前类的对象需要spring来管理。
//          里面的名字就相当于bean标签的id，作为对象的唯一标识
@Component("stu")
public class Student {
    private String name;
    private String sex;
    private Integer age;

    public Student() {
        System.out.println("=====Student 无参构造=====");
    }

    public Student(String name, String sex, Integer age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("========setName========:"+name);
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

Test:

package com.test;

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

import javax.annotation.Resource;

public class Test {
    @Resource
    private Student stu;
    public static void main(String[] args) {
        //创建spring容器

        ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-1.xml"); //运行结果：=====Student 无参构造===== ========setName========:张三
    }

}

Test2:

package com.test;

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

public class Test2 {
    public static void main(String[] args) {
        //通过注解从spring容器中获取对象
        //1.在spring配置文件中，配置包扫描
        //2.在需要被spring管理的类上加特定注解
        ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-1.xml");

        Student stu=ctx.getBean(Student.class);
        System.out.println(stu); //运行结果：=====Student 无参构造===== ========setName========:张三  Student{name='张三', sex='男', age=20}

        Student stu1=(Student)ctx.getBean("stu");
        System.out.println(stu1); //运行结果： Student{name='张三', sex='男', age=20}
    }
}

spring-2.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">


    <context:component-scan base-package="com.test2"/>
</beans>

Car:

package com.test2;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

@Component("mycar") //通过注释，可以用在任意对象上
//@Service  //本质就是@Component这个注释的别名，用于Service层的对象
//@Repository //本质就是@Component这个注释的别名，用于数据访问层的对象
public class Car {
    //品牌
    @Value("宝马")
    private String brand;
    //价格
    @Value("2000")
    private int price;
    //时速
    @Value("120")
    private int space;

    public Car() {
    }

    public Car(String brand, int price, int space) {
        this.brand = brand;
        this.price = price;
        this.space = space;
    }

    public void run(){
        System.out.println(this.brand+"在跑");
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int getSpace() {
        return space;
    }

    public void setSpace(int space) {
        this.space = space;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                ", space=" + space +
                '}';
    }
}

Driver:

package com.test2;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component  //当注释没有指定id名字的时候，spring自动用类名小驼峰做对象的id名
public class Driver {
    //@Value只用于注入普通值
    @Value("张三")
    private String name;
    @Value("20")
    private Integer age;

    //@Autowired 用于注入对象类型的值（按照类型注入对象，前提是spring容器中有该类型的对象）
    //           该注释属于spring框架下的注释。特征是按照类型注入对象
    //@Autowired
    @Resource
    private Car car;

    public Driver() {
    }

    public Driver(String name, Integer age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }

    //开车
    public void drive(){
        System.out.println(this.name+"开车");
        this.car.run();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        //注解方式没有调用setter方法
        System.out.println("==========setName==============:"+name);
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

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

Test:

package com.test2;

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

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("spring-2.xml");
        //获取容器中的司机对象
        Driver driver=ctx.getBean(Driver.class);
        //调用开车的方法
        driver.drive(); //运行结果：张三开车 宝马在跑


        Car car=ctx.getBean(Car.class);
        System.out.println(car);   //运行结果：Car{brand='宝马', price=2000, space=120}

        Car mycar=(Car)ctx.getBean("mycar");
        System.out.println(mycar); //运行结果：Car{brand='宝马', price=2000, space=120}
    }

}

spring-3.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.test3"/>
</beans>

IA:

package com.test3;

public interface IA {
    void test();
}

ClsA1:

package com.test3;

import org.springframework.stereotype.Component;

@Component
public class ClsA1 implements IA{
    @Override
    public void test() {
        System.out.println("这是A1测试");
    }
}

ClsA2:

package com.test3;

import org.springframework.stereotype.Component;

@Component
public class ClsA2 implements IA{
    @Override
    public void test() {
        System.out.println("这是A2测试");
    }
}

MyCls:

package com.test3;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component //当注释没有指定id名字的时候，spring自动用类名小驼峰做对象的id名
public class MyCls {
//    @Autowired
//    private IA a;  //运行结果：ERROR:expected single matching bean but found 2: clsA1,clsA2

//    //@Autowired先按类型，再按照名字注入
//    @Autowired
//    private IA clsA1;    //指定名字注入。 ClsA1类名小写clsA1 。
//
//    public void show(){
//        this.clsA1.test();
//    }                   //运行结果：这是A1测试

    //@Autowired先按类型，再按照名字注入
    @Autowired
    @Qualifier("clsA1") //按名字注入对象a
    private IA a;

    public void show(){
        this.a.test();
    }                   //运行结果：这是A1测试

}

MyCls2:

package com.test3;

import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
public class MyCls2 {

//    @Resource(name = "clsA1")
//    private IA a;
//
//    public void show(){
//        this.a.test();
//    }                   //运行结果：这是A1测试

//    @Resource
//    private IA clsA1; //指定名字注入
//
//    public void show(){
//        this.clsA1.test();
//    }                   //运行结果：这是A1测试

//    //先按名字，再按类型注入
//    @Resource
//    private IA a;
//
//    public void show(){
//        this.a.test();
//    }  //运行结果：BeanNotOfRequiredTypeException: Bean named 'a' is expected to be of type 'com.test3.IA' but was actually of type 'com.test3.Dog'

    //先按名字，再按类型注入
    @Resource
    private IA a;

    public void show(){
        this.a.test();
    } //运行结果：NoUniqueBeanDefinitionException: No qualifying bean of type 'com.test3.IA' available: expected single matching bean but found 2: clsA1,clsA2
}

Dog:

package com.test3;

import org.springframework.stereotype.Component;

//@Component("a")
@Component("dog")
public class Dog {

}

Test:

package com.test3;

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

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring-3.xml");
        MyCls myCls=ac.getBean(MyCls.class);
//        ac.getBean(MyCls.class);
        myCls.show();
    }
}

Test2:

package com.test3;

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

public class Test2 {
    public static void main(String[] args) {
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring-3.xml");
        MyCls2 myCls2=ac.getBean(MyCls2.class);
        myCls2.show();
    }

}

讲解参考：

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

// A code block
var foo = 'bar';


// A code block
var foo = 'bar';


// A code block
var foo = 'bar';


// A code block
var foo = 'bar';


// A code block
var foo = 'bar';
小丫头爱打盹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCache框架加载/拦截原理详解
08-26
配置SpringCache可以通过注解或XML的方式。在注解方式下，我们通常会在配置类上使用`@EnableCaching`来开启缓存功能。例如，在`CacheConfigure`类中，我们可以定义`cacheManager`和`errorHandler`，并创建一个或多个...
Spring注解方式防止重复提交原理详解
08-26
Spring 注解方式防止重复提交原理详解 Spring 注解方式防止重复提交原理详解是 Spring 框架中的一种防止重复提交的方法。该方法通过使用注解和拦截器来实现防止重复提交。 首先，我们需要定义一个 annotation，名...
Spring Bean管理注解方式代码实例
08-19
Spring Bean 管理注解方式代码实例 Spring Bean 管理注解方式代码实例是 Spring 框架中的一种常见的 Bean 管理方式。通过使用注解的方式，可以简化 Bean 的配置和管理过程。这篇文章将详细介绍 Spring Bean 管理...
spring boot注解方式使用redis缓存操作示例
08-25
本文将详细讲解如何使用注解方式在Spring Boot中进行Redis缓存操作。 首先，要使用Redis缓存，你需要在`pom.xml`文件中引入相应的依赖库。以下是两个关键的依赖： ```xml <groupId>org.springframework.boot</...
Spring MVC完全注解方式配置web项目
09-01
本篇文章将详细讲解如何使用完全注解的方式配置一个Spring MVC的web项目，这种方式适用于Servlet 3.0及以上版本的web容器。 首先，Spring MVC的核心组件是`DispatcherServlet`，它负责接收HTTP请求并分发到相应的...
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 440
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
Vue 3 和 SpringBoot 实现文件分片上传示例
exlink2012的专栏
07-22 415
实现分片上传，并使用Spring Boot在后端保存文件。前端将文件分片并逐个上传到后端，后端接收到所有分片后再进行合并，最终保存为一个完整文件。
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
小哇
07-23 311
zookeeper安装并成功运行。
SpringCloud之使用 Nacos 实现高效购物车商品信息处理
最新发布
Takumilove的博客
07-24 962
通过上述步骤，我们成功实现了一个高效的购物车商品信息处理流程。使用 Nacos 来进行服务发现，并结合手写的负载均衡策略，确保了服务调用的高可用性和稳定性。这样不仅提升了系统的性能，还能给用户带来更好的购物体验。
【springboot】中使用--WebMvcConfigurer
2201_75743716的博客
07-19 925
import com/*** 将请求参数字符串转为 DeviceInfo");} }/*** 将请求参数字符串转为 DeviceInfo");} }/*** 将请求参数字符串转为 DeviceInfo");import org/*** 将请求参数字符串转为 DeviceInfo");} }/**
SpringMVC 控制层框架-下
woai3364的博客
07-20 1094
因此，在开发过程中，合理处理异常、避免异常产生、以及对异常进行有效的调试是非常重要的。如果张三负责的模块按照 A 方案处理异常，李四负责的模块按照 B 方案处理异常...各个模块处理异常的思路、代码、命名细节都不一样，那么就会让整个项目非常混乱。在Web 应用三层架构体系中，表述层负责接收浏览器提交的数据，业务逻辑层负责数据的处理。一个网站有 5、6个资源，其中有一个为登录资源，两个无需登录即可访问，另外三个需要登录后才能访问，如果不登录就访问那三个资源，需要拦截，并且提示登录后访问。
Springboo3中使用虚线程
java scala
07-19 380
Java中的虚线程类似Go中的协程，简单来说可以通过同步编程的方式来达到异步编程模式的效果，
SpringBoot启动命令过长
tiantiantbtb的博客
07-24 144
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 854
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,
Spring Task详解
SRY12240419的博客
07-24 290
Spring Task是Spring框架提供的任务调度工具，可以按照约定的时间自动执行某个代码逻辑
Java 和 SpringBoot 中的设计模式 详解
weixin_68074170的博客
07-19 746
假如有一结果api结果返回值的类Person，其在代码中频繁被使用。这两种使用方法的弊端有：（1）：当只需要部分参数的时候需要再定义个构造函数（比如失败的情况只需要code和message，结果肯定是空，因此不需要data），且一旦参数较多，则；（2）；Lombok插件的@Builder注解。
手写简易版Spring IOC容器02【学习】
weixin_44794897的博客
07-19 609
其中applyPropertyValues用于从beanDefinition中读取属性的配置信息然后通过BeanUtil(hutool-all中提供的类)为其赋值@Overridetry {// 创建bean实例Class<?if (null!break;// 设置属性值try {// 从beanDefinition中获取property通过Resource获取文件流。
Spring通过工厂方法进行配置
学习笔记，人工智能，教程，技术分享！
07-21 448
工厂类CarStaticFactoryxml配置。
【OAuth2系列】集成微信小程序登录到 Spring Security OAuth 2.0
c18213590220的博客
07-21 1696
本文将详细介绍如何在 Spring Security OAuth 2.0 中扩展支持微信小程序登录，通过自定义授权方式实现无缝登录。
Spring3MVC注解教程：命令/表单对象绑定
"本教程主要介绍了Spring3 MVC中如何使用注解进行命令/表单对象绑定，以及Spring MVC框架的基本架构和核心组件。通过实例展示了控制器的定义和HTTP请求的映射，同时还提及了Spring MVC的新特性及其在企业应用开发中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值