Spring核心之IOC--注解开发

最新推荐文章于 2021-08-15 23:06:55 发布
最新推荐文章于 2021-08-15 23:06:55 发布
阅读量189 收藏 1
点赞数
分类专栏： 企业级开发框架SSM 文章标签： spring java mysql IOC
原文链接：www.lagou.com
版权

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代  替xml配置文件可以简化配置，提高开发效率。

1. Spring常用注解

1.1 介绍

Spring常用注解主要是替代<bean> 的配置

注解

说明

@Component

使用在类上用于实例化Bean

@Controller

使用在web层类上用于实例化Bean

@Service

使用在service层类上用于实例化Bean

@Repository

使用在dao层类上用于实例化Bean

@Autowired

使用在字段上用于根据类型依赖注入

@Qualifier

结合@Autowired一起使用,根据名称进行依赖注入

@Resource

相当于@Autowired+@Qualifier，按照名称进行注入

@Value

注入普通属性

@Scope

标注Bean的作用范围

@PostConstruct

使用在方法上标注该方法是Bean的初始化方法

@PreDestroy

使用在方法上标注该方法是Bean的销毁方法

说明：

JDK11以后完全移除了javax扩展导致不能使用@resource注解

需要maven引入依赖

 

<dependency>

<groupId>javax.annotation</groupId>

<artifactId>javax.annotation-api</artifactId>

<version>1.3.2</version>

</dependency>

注意

使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包  下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。

<!--注解的组件扫描-->

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

1.2 实现

（1）Bean实例化（IOC）

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"></bean>

使用@Compont或@Repository标识UserDaoImpl需要Spring进行实例化。

// @Component(value = "userDao")

@Repository // 如果没有写value属性值，Bean的id为：类名首字母小写

public class UserDaoImpl implements UserDao {

}

（2）属性依赖注入（DI）

<bean id="userService" class="com.lagou.service.impl.UserServiceImpl">

<property name="userDao" ref="userDaoImpl"/>

</bean>

使用@Autowired或者@Autowired+@Qulifier或者@Resource进行userDao的注入

@Service

public class UserServiceImpl implements UserService {

 

@Autowired

private UserDao userDao;

 

// <property name="userDao" ref="userDaoImpl"/>

// @Autowired

// @Qualifier("userDaoImpl")

// @Resource(name = "userDaoImpl")

public void setUserDao(UserDao userDao) { this.userDao = userDao;

}

}

（3）@Value

使用@Value进行字符串的注入，结合SPEL表达式获得配置参数

@Service

public class UserServiceImpl implements UserService {

 

@Value("注入普通数据") private String str; @Value("${jdbc.driver}") private String driver;

 

}

（4）@Scope

<bean scope=""/>

使用@Scope标注Bean的范围

@Service @Scope("singleton")

public class UserServiceImpl implements UserService {{

 

}

（5）Bean生命周期

<bean init-method="init" destroy-method="destory" />

使用@PostConstruct标注初始化方法，使用@PreDestroy标注销毁方法

@PostConstruct public void init(){

System.out.println("初始化方法 ");

}

 

@PreDestroy

public void destroy(){ System.out.println("销毁方法 ");

}

1.3 Spring新注解

使用上面的注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下：

  • 非自定义的Bean的配置：<bean>

 

  • 加载properties文件的配置：<context:property-placeholder>

 

  • 组件扫描的配置：<context:component-scan>

 

  • 引入其他文件：<import>

注解

说明

@Configuration

用于指定当前类是一个Spring 配置类，当创建容器时会从该类上加载注解

@Bean

使用在方法上，标注将该方法的返回值存储到 Spring 容器中

@PropertySource

用于加载 properties 文件中的配置

@ComponentScan

用于指定 Spring 在初始化容器时要扫描的包

@Import

用于导入其他配置类

 

2. Spring纯注解整合DbUtils

2.1 编写Spring核心配置类

SpringConfig类

package com.lagou.config;

import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.*;

import javax.sql.DataSource;

@Configuration
@ComponentScan("com.lagou")
@Import(DataSourceConfig.class)
//@PropertySource("classpath:jdbc.properties")
public class SpringConfig {



    @Bean("queryRunner")
    public QueryRunner getQueryRunner(@Autowired  DataSource dataSource){

        QueryRunner queryRunner = new QueryRunner(dataSource);
        return  queryRunner;
    }




}

DataSourceConfig类

package com.lagou.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfig {


    @Value("${jdbc.driverClassName}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;


    @Bean("dataSource")
    public DataSource getDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }




}

2.2 其它类采用纯注解方式

AccountDaoImpl类

package com.lagou.dao.impl;

import com.lagou.dao.AccountDao;
import com.lagou.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.sql.SQLException;
import java.util.List;

@Repository //相当于配置了bean标签
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private QueryRunner queryRunner;



    public List<Account> findAll() {

        List<Account> list = null;
        //编写sql
        String sql = "select * from account";
        try {
            // 执行sql
            list = queryRunner.query(sql, new BeanListHandler<Account>(Account.class));

        } catch (SQLException e) {
            e.printStackTrace();
        }

        return list;
    }

    public Account findById(Integer id) {

        Account query = null;
        // 编写sql
        String sql = "select * from account where id = ?";

        try {
             query = queryRunner.query(sql, new BeanHandler<Account>(Account.class),id);
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return query;
    }

    public void save(Account account) {

        String sql = "insert into account values(null,?,?)";
        try {
            queryRunner.update(sql,account.getName(),account.getMoney());
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    public void update(Account account) {

        String sql = "update account set name = ?,money = ? where id = ?";
        try {
            queryRunner.update(sql,account.getName(),account.getMoney(),account.getId());
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    public void delete(Integer id) {

        String sql = "delete from account where id = ?";
        try {
            queryRunner.update(sql,id);
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}

AccountServiceImpl类

package com.lagou.servlet.impl;

import com.lagou.dao.AccountDao;
import com.lagou.domain.Account;
import com.lagou.servlet.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;


@Service("accountService")  //相当于配置了bean标签  id属性
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao aDao;


    public List<Account> findAll() {

        return  aDao.findAll();
    }

    public Account findById(Integer id) {

        return aDao.findById(id);
    }

    public void save(Account account) {

        aDao.save(account);

    }

    public void update(Account account) {

        aDao.update(account);

    }

    public void delete(Integer id) {

        aDao.delete(id);

    }
}

AccountServiceTest测试类

package com.lagou.test;

import com.lagou.config.SpringConfig;
import com.lagou.domain.Account;
import com.lagou.servlet.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class) //@RunWith指定junit的运行环境  SpringJUnit4ClassRunner是spring提供的作为junit运行环境的类
// @ContextConfiguration({"classpath:applicationContext.xml"})
@ContextConfiguration(classes = {SpringConfig.class})
public class AccountServiceTest {

    //ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
   // AccountService accountService = (AccountService) classPathXmlApplicationContext.getBean("accountService");

    // 当前改成了纯注解形式
/*    AnnotationConfigApplicationContext annotationConfigApplicationContext =   new AnnotationConfigApplicationContext(SpringConfig.class);
    AccountService accountService = (AccountService) annotationConfigApplicationContext.getBean("accountService");*/

    @Autowired
    private AccountService accountService;


    //测试添加
    @Test
    public void testSave(){

        Account account = new Account();
        account.setName("lucy");
        account.setMoney(888d);
        accountService.save(account);

    }

    //测试查询
    @Test
    public void testFindById(){
        Account account = accountService.findById(3);
        System.out.println(account);

    }


    //测试查询所有
    @Test
    public void testFindAll(){
        List<Account> all = accountService.findAll();
        for (Account account : all) {
            System.out.println(account);
        }

    }

    //测试更新
    @Test
    public void testUpdate(){
        Account account = new Account();
        account.setId(3);
        account.setName("jack");
        account.setMoney(2000d);

        accountService.update(account);
    }

    //测试删除
    @Test
    public void testDelete(){
        accountService.delete(3);
    }









}

applicationContext.xml 与 jdbc.properties 直接删除

3. Spring整合Junit

3.1 普通Junit测试问题

在普通的测试类中，需要开发者手动加载配置文件并创建Spring容器，然后通过Spring相关API获得

Bean实例；如果不这么做，那么无法从容器中获得对象。

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

AccountService accountService = applicationContext.getBean(AccountService.class);

我们可以让SpringJunit负责创建Spring容器来简化这个操作，开发者可以直接在测试类注入Bean实  例；但是需要将配置文件的名称告诉它。

3.2  Spring整合Junit

步骤分析：

  1. 导入spring集成Junit的坐标
  2. 使用@Runwith注解替换原来的运行器
  3. 使用@ContextConfiguration指定配置文件或配置类
  4. 使用@Autowired注入需要测试的对象
  5. 创建测试方法进行测试

（1）导入spring集成Junit的坐标

（2）使用@Runwith注解替换原来的运行器

@RunWith(SpringJUnit4ClassRunner.class) 
public class SpringJunitTest {

}

（3）使用@ContextConfiguration指定配置文件或配置类

@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration(value = {"classpath:applicationContext.xml"}) 加载spring 核心配置文件
@ContextConfiguration(classes = {SpringConfig.class}) // 加载spring核心配置类
public class SpringJunitTest {

}

（4）使用@Autowired注入需要测试的对象

@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration(classes = {SpringConfig.class}) 
public class SpringJunitTest {

    @Autowired
    private AccountService accountService;
}

（5）创建测试方法进行测试

@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration(classes = {SpringConfig.class}) 
public class SpringJunitTest {

    @Autowired
    private AccountService accountService;

    //测试查询@Test
    public void testFindById() {
        Account account = accountService.findById(3); System.out.println(account);
    }
}

 

 

节选自拉钩教育JAVA系列课程

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

enterpc
关注
专栏目录
Spring通过注解实现IOC
04-18
Spring通过注解实现IOC，Spring通过注解实现IOC，Spring通过注解实现IOC
Bean的依赖注入的数据类型
Leon_Jinhai_Sun的博客
09-03 230
上面的操作，都是注入的引用Bean，处了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。 注入数据的三种数据类型 普通数据类型 引用数据类型 集合数据类型 其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的，下面将以set方法注入为例，演示普通数据类型和集合数据类型的注入。 Bean的依赖注入的数据类型 （1）普通数据类型的注入 public class UserDaoImpl implements UserDao { private S
Spring IOC 之注解配置、单元测试
guanhang89的专栏
10-17 547
Spring IOC 之注解配置、单元测试 注解方式配置步骤（非maven项目） 步骤一：导入注解开发所有需要的jar包 引入IOC容器必须的6个jar包 多引入一个：Spring框架的AOP的jar包，spring-aop的jar包 步骤二：创建对应的包结构，编写Java的类 UserService – 接口 UserServiceImpl
Spring注解开发---IOC
Xyulu的博客
08-15 153
文章目录组件注册@Configuration 配置spring@ComponentScan 自动扫描组件@Scope 设置作用域@Lazy 注解实现懒加载@Conditional 条件注入@Import 注解导入组件@FactoryBean 注册组件 组件注册 @Configuration 配置spring @Configuration启动容器+@Bean注册Bean @Configuration启动容器+@Component注册Bean 使用 AnnotationConfigApplicationCo
IOC的注解开发
Hitmi_的博客
12-19 313
文章介绍：在前面，我们使用在applicationContext.xml文件中写<bean>标签的方式完成Bean对象的管理，并在<bean>标签下通过<property>等标签完成属性注入，还有init-method、estroy-metho等属性为一个Bean类配置初始化方法和构造方法。这一切都是在applicationContext.xml这个配置文件下完...
spring-demo02-IOC-DI案例.zip
08-07
Spring 框架是 Java 开发中不可或缺的一部分，它以其强大的依赖注入（Dependency Injection, DI）和控制反转（Inversion of Control, IOC）特性而闻名。在这个名为“spring-demo02-IOC-DI案例”的压缩包中，我们将...
spring-demo10-注解-IOC.zip
08-08
在IT行业中，Spring框架是Java企业级应用开发的首选框架之一，因其强大的功能和灵活性而备受推崇。在Spring中，依赖注入（Dependency Injection，简称DI）是核心特性，而注解（Annotation）则是实现DI的一种现代化...
Java-Spring-SpringIoC容器-SpringIoC的学习
10-11
在Java Spring框架中，Spring IoC（Inversion of Control，控制反转）是核心特性之一，它使得应用程序的组件之间的依赖关系不再由代码直接管理，而是交由Spring IoC容器负责。这种设计模式降低了代码间的耦合，提高...
Spring-IoC-DI-main
02-11
标题“Spring-IoC-DI-main”提示我们讨论的核心是Spring框架中的两个核心特性：控制反转（Inversion of Control, IoC）和依赖注入（Dependency Injection, DI）。这两个概念是Java开发中的重要基石，尤其在构建大型...
Spring核心-IOC（3）
最新发布
03-12
在Spring框架中，IOC（Inversion of Control，控制反转）是其核心概念之一，它改变了传统应用程序中的对象创建和管理方式。本篇文章将深入探讨Spring的IOC容器以及它如何通过自动装配（Autowired）来实现依赖注入，...
Spring学习（七）Spring IOC中的注解开发
学习是为了让运气刚好能碰上你的努力
05-15 279
Spring学习（七）Spring IOC中的注解开发spring IOC中的注解开发@Autoware@Resource注解@Nullable@Component@Configuration小结 spring IOC中的注解开发 JDK1.5支持了注解，spring2.5就支持注解了。然后如果是在spring4之后，还需要导入aop的包才能使用注解开发。 要使用注解: 文档1.9： 1.导入context注解约束：xmlns:context="http://www.springframework.org/
带你了解Spring-IOC注解开发
zaza_a的博客
02-24 204
一、背景-顺应历史潮流 随着Springboot开发的流行，我们也开始频繁的使用注解开发，今天理一下常见的Spring-IOC注解。以下代码经过我亲测，有不对的地方望指点纠正 二、使用与测试 测试代码的结构： 在开始之前先来一波以前利用xml配置文件创建注入的方法： 新建实体类Person.class public class Person { private String name; priva...
ioc注解开发
小汤圆
05-01 121
IOC 注解开发 示例 引入jar包： 除了要引入上述的四个包之外，还需要引入aop包。 创建 applicationContext.xml ，使用注解开发引入 context 约束（xsd-configuration.html） <beans xmlns=“http://www.springframework.org/schema/beans” xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://w
ioc的注解开发
weixin_36957153的博客
10-06 163
xml开发与ioc开发的优缺点 xml管理bean比较容易，但配置麻烦 使用ioc注解就比较难管理，的到类内部去看具体的注解，但操作简单 一般都是两种结合一起开发 使用之前 必须添加约束之类的，直接贴代码吧 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework....
Spring的IOC常用注解(含源码)
Java圈全能架构师的博客
03-09 309
一、容器中注入组件 1，包扫描 + 组件标注注解 　　源码：Demo01_ComponentScan a）组件标注 @Controller @Service @Repository @Component b）包扫描@ComponentScan 　　@ComponentScan中主要值得解释 value：扫描的包路径(数组) excludeFilters：指定扫描的时候按照什么规则排除那些组件(@ComponentScan.Filter)includeFilters：指定扫描的时候只需要包
SpringIOC之注解开发
记录一只菜鸡的成长之路
10-13 196
文章目录一、注解创建对象1.概述2.使用案例二、注解实现注入1.概述2.使用案例三、注解修改生命周期1.概述2.使用案例四、Spring中的jdbc1.概述2.使用案例-实现增删查改3.自定义映射器五、注解实现纯注解开发1.要用到的注解2.步骤3.实现代码拓展、Spring整合Junit 一、注解创建对象 1.概述 常用注解： 注解 说明 @Component 修饰类，即表示把这个类添加到IOC容器中，由IOC容器创建 @Service 修饰类，表示这是一个业务层的类，并且由IOC容器创
Spring IOC注解开发
Switch的博客
02-07 4415
Spring IOC注解开发@(Spring)[Spring, ioc, 注解]Spring IOC注解开发 Spring的IOC的注解使用步骤 创建项目引入jar包 引入配置文件 创建相关包和类 将类的控制权交给Spring容器 编写测试 依赖注入 Spring的IOC注解的详解 Bean定义注解 Bean依赖注入注解 Bean的作用范围的注解 Bean的生命周期注解 Spring的IOC的XML
注解的IOC
肉man
10-01 703
基于注解的IOC配置 写在最前 学习基于注解的IoC配置，大家脑海里首先得有一个认知，即注解配置和xml配置要实现的功能都是一样的，都是要降低程序间的耦合。只是配置的形式不一样。 关于实际的开发中到底使用xml还是注解，每家公司有着不同的使用习惯。所以这两种配置方式我们都需要掌握。 环境搭建 第一步：拷贝必备jar包到工程的lib目录。 注意：在基于注解的配置中，我们还要多拷贝一个aop的jar包...
Spring注解开发（一）——使用注解往IOC中注入一个实例
cj_eryue的博客
10-28 311
新建一个maven项目并添加spring-context 依赖 <!--https://mvnrepository.com/artifact/org.springframework/spring-context--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <v
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值