Spring框架核心IOC的使用：配置式开发+注解式开发+纯注解式开发

已于 2024-05-22 17:40:14 修改
阅读量883 收藏 18
点赞数 26
分类专栏： 框架学习 文章标签： spring 数据库 java
于 2024-05-22 17:38:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a289246/article/details/139117181
版权

Spring框架核心IOC的使用：配置式开发+注解式开发+纯注解式开发

Spring框架IOC合集：
Spring框架核心IOC的使用：IOC的作用+Bean管理+实例化Bean的方式+DI依赖注入
Spring框架核心IOC的使用：配置式开发+注解式开发+纯注解式开发

一、准备工作

1.1 配置maven

新建maven项目（maven的下载安装及配置）
pom文件中加入坐标依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.12</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

<!-- 连接池-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>
<!-- mysql驱动包-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.6</version>
</dependency>

1.2 创建数据库

create database spring_db;
use spring_db;
create table account(
id int primary key auto_increment,
name varchar(40),
money double
)character set utf8 collate utf8_general_ci;
INSERT INTO `account` VALUES ('1', '老王', '1000');
INSERT INTO `account` VALUES ('2', '小王', '1000');
INSERT INTO `account` VALUES ('3', 'ccc', '1000');

在这里插入图片描述

在entity包下新建Account类，与数据库中的account相对应

public class Account {
    private int id;
    private String name;
    private Double money;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

二、IOC配置文件开发的示例

2.1 配置dao层

在dao层下新建接口AccountDao，新建包impl，在impl下新建类AccountDaoImpl，重写findAll方法

public interface AccountDao {
    //查询所有账号
    public List<Account> findAll() ;
}

在连接池这一部分，用set方法注入的方式，注入druidDataSource，也就是给它赋值

public class AccountDaoImpl implements AccountDao {
    private DruidDataSource druidDataSource;

    public void setDruidDataSource(DruidDataSource druidDataSource) {
        this.druidDataSource = druidDataSource;
    }

    @Override
    public List<Account> findAll(){
        //创建连接池
//        DruidDataSource druidDataSource = new DruidDataSource();
//        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
//        druidDataSource.setUrl("jdbc:mysql://localhost:3306/spring_db");
//        druidDataSource.setUsername("root");
//        druidDataSource.setPassword("2020");

        //创建数据库对象
        Connection connection=null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        List<Account> list = new ArrayList<Account>();
        //获取连接
        try {
            connection = druidDataSource.getConnection();


            //编写sql
            String sql = "select * from account";
            //预编译
            statement = connection.prepareStatement(sql);
            //执行sql语句
            resultSet = statement.executeQuery();
            //遍历结果集
            while (resultSet.next()){
                Account account = new Account();
                account.setId(resultSet.getInt("id"));
                account.setName(resultSet.getString("name"));
                account.setMoney(resultSet.getDouble("money"));
                list.add(account);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }


        return list;
    }
}

2.2 配置service层

接下来在service层下新建接口AccountService，新建impl包，包下新建AccountServiceImpl类

public interface AccountService {
    //查询所有账号
    public List<Account> findAll() ;
}

重写的findAll调用dao层的findAll方法，在这里注入accountDao

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List<Account> findAll() {

        return accountDao.findAll();
    }
}

完成dao层service层还有entity层之后的目录层级

在这里插入图片描述

2.3 配置applicationContext2.xml

接下来是配置文件

<!--    连接池对象-->
    <bean id="dr" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_db"></property>
        <property name="username" value="root"></property>
        <property name="password" value="2020"></property>
    </bean>
<!--    service层-->
    <bean id="asi" class="com.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="adi"></property>
    </bean>
<!--    dao层-->
    <bean id="adi" class="com.dao.impl.AccountDaoImpl">
        <property name="druidDataSource" ref="dr"></property>
     </bean>

2.4 测试

创建测试类AccountServiceTest

在这里插入图片描述

public class AccountServiceTest {
    @Test
    public void run(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext2.xml");
        AccountService as = (AccountService) ac.getBean("asi");
        List<Account> all = as.findAll();

        for (Account account:all){
            System.out.println(account);
        }

    }
}

运行结果
在这里插入图片描述

三、IOC注解式开发

3.1 开启注解扫描

在配置文件中加入

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

在加载配置文件时会扫描com包中的类，有哪些交给ioc管理

3.2 bean管理类常用的注解

bean管理类常用的4个注解（作用相同，推荐使用在不同分层上）

  1. @Component 普通的类
  2. @Controller 表现层的类
  3. @Service 业务层的类
  4. @Repository 持久层的类

3.3 依赖注入相关的注解

  1. @Value 用于注入简单类型（基本类型+字符串）

  2. @Autowired 默认按类型进行自动装配（自定义引用类型）

  3. @Qualifier 不能单独使用，必须要和@Autowired一起使用，使用value参数指定名称，强制使用名称注入

  4. @Resource java提供的注解，也可以达到强制使用名称注入的作用，这个注解可以单独使用，但是注意使用name参数指定名称

3.4 对象生命周期注解

@Scope 取值singleton（单例）prototype（多例）

3.5 初始化方法和销毁方法注解

  1. @PostConstruct 相当于init-method 该注解作用到方法上
  2. @PreDestroy 相当于destroy-method 该注解作用到方法上

3.6 示例

新建Person类
加入注解@Component，此类交给ioc管理，不加参数默认的标识是person
@Value(“LiMing”)给变量name注入值

@Component
public class Person {
    @Value("LiMing")
    private String name;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

新建类Car，在这个类中给Person类型的变量注入值@Autowired，按照类型注入，如果要按照名称注入，需加入注解@Qualifier(“person”)

@Component
public class Car {
    @Value("xiaomiSU7")
    private String name;

    @Autowired
    private Person person;

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", person=" + person +
                '}';
    }
}

在配置文件中开启注解扫描

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

编写测试类，然后运行

    @Test
    public void run(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext2.xml");
        Car car = (Car) ac.getBean("car");
        System.out.println(car);
    }

在这里插入图片描述

四、IOC纯注解式开发

IOC纯注解开发使用配置类代替配置文件中的注解扫描

  • @Configuration声明当前类是配置类
  • @ComponentScan(“com”)扫描指定的包
  • @Import(SpringConfig2.class)导入其他的配置类
  • @Bean只能写到方法上，表明使用此方法创建一个对象，并把创建好的对象保存到ioc容器中，可以帮助我们配置第三方的类
  • 创建工厂，加载配置类：
    ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);

4.1 新建配置类

新建util包，包里面新建配置类

在这里插入图片描述

//声明当前类是配置类
@Configuration
//扫描指定的包
@ComponentScan("com")
//导入其他的配置类
@Import(SpringConfig2.class)
public class SpringConfig {
    //@Bean只能写到方法上，表明使用此方法创建一个对象，并把创建好的对象保存到ioc容器中
    @Bean
    public DruidDataSource createDataSource(){

        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/spring_db");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("2020");

        return druidDataSource;
    }
}

public class SpringConfig2 {
}

主配置类有注解@Configuration，导入的配置类可以没有@Configuration

4.2 配置service层和dao层

修改AccountDaoImpl类，使用注解注入，并且将类交给ioc管理

@Repository
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private DruidDataSource druidDataSource;


    @Override
    public List<Account> findAll(){
        //创建连接池

        //创建数据库对象
        Connection connection=null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        List<Account> list = new ArrayList<Account>();
        //获取连接
        try {
            connection = druidDataSource.getConnection();


            //编写sql
            String sql = "select * from account";
            //预编译
            statement = connection.prepareStatement(sql);
            //执行sql语句
            resultSet = statement.executeQuery();
            //遍历结果集
            while (resultSet.next()){
                Account account = new Account();
                account.setId(resultSet.getInt("id"));
                account.setName(resultSet.getString("name"));
                account.setMoney(resultSet.getDouble("money"));
                list.add(account);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }


        return list;
    }
}

修改AccountServiceImpl

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Override
    public List<Account> findAll() {

        return accountDao.findAll();
    }
}

4.3 测试

修改测试类中的run方法

@Test
public void run(){


    //创建工厂，加载配置类
    ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);
    AccountService accountService = (AccountService) ac.getBean("accountServiceImpl");
    System.out.println(accountService.findAll());

}

运行结果

在这里插入图片描述

JiaIYzzz
关注
  • 26
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
go-spring：基于IoC的Go一级一站式开发框架:rocket:
02-05
Go-Spring当前使用Go1.12进行开发，使用Go Modules进行依赖管理。IoC容器Go-Spring不仅实现了如Java Spring那般功能强大的IoC容器，还扩展了Bean的概念。在Go中，对象（即指针），数组，地图，函数指针，这些都是...
Spring+3.x企业应用开发实战光盘源码(全)
03-27
　第7章：对如何使用基于AspectJ配置AOP的知识进行了深入的分析，这包括使用XML Schema配置文件、使用注解进行配置等内容。 　第8章：介绍了Spring所提供的DAO封装层，这包括Spring DAO的异常体系、数据访问模板等...
手把手教你整合最优雅SSM框架：SpringMVC + Spring + MyBatis
热门推荐
小疯的代码健身房
05-08 61万+
小疯手把手带你整合SpringMVC+Spring+MyBatis三大框架，俗称SSM，用它完全代替传统的SSH框架，把它们最优雅的一面发挥出来。整合配置结束后，会有一个应用实例“图书管理系统”带给大家，希望能快速上手这个框架！
Spring IoC注解式开发
????
03-04 1691
Spring IoC注解式开发，这部分是相当重要的，尤其是到SpringBoot的全注解式开发，在实际开发中也是使用注解的方式。
Spring——XML配置事务、注解+XML、纯注解的配置方式
Guizy
03-18 7700
三、基于 xml 配置声明式事务 1、解决银行转账问题: 在上面引出事务的代码基础上,只需要修改xml配置文件 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2...
【Spring篇】IOC/DI注解开发
Javascript_tsj的博客
04-30 4294
三、
IDEA项目实践——Spring框架简介，以及IOC注解
张小鱼的博客
08-07 1873
本文主要是对spring框架的简单介绍以及LOC控制反转介绍，以及基于xml的DI和注解开发案例讲解，文章当中的案例经供参考。具体的开发应用要按照具体的开发来书写。Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发的复杂性而创建的。Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。Spring 是可以在 Java SE/EE 中使用的轻量级开源框架。Spring 的主要作用就是为代码“解耦”，降低代码间的耦合度。
提升效率：使用注解实现精简而高效的Spring开发
m0_59230408的博客
12-30 7262
springIOC/DI注解开发
如何高效提升Java开发效率—Spring注解开发全套教程！
累计发表博客60余万字，CSDN 博客专家、Java 领域优质创作者、华为云享专家、阿里云专家博主。专注分享 Java 优质文章，毕设实战项目开发，全网粉丝10W+
07-19 4392
精彩干货索引 一、使用注解标识组件 二、组件扫描 1、普通扫描 2、包含与排除特定组件 （1）扫描包含特定组件 （2）扫描排除特定组件 3、实现注解的三步骤 三、组件自动装配 1、@autowired注解 （1）@autowired装配原理 （2）@Qualifier指定装配ID （3）required—装配报错解决 （4）特殊属性的自动装配 2、@Resource注解 3、@Inject注解 四、注解使用的小细节 1、整合多个配置文件 2、路径书写问题 3、获取组件时
开发框架：Spring/SpringBoot+SpringMVC+MyBatis
a_123456598的博客
12-17 3017
【Spring】 1.Spring 【问】Spring？Spring Boot和Spring的区别？ Spring：是一个轻量级控制反转（IOC）和面向切面（AOP）的容器框架。 Spring Boot： 2.IOC理论推导 【问】解释IOC？ （1）先解释IOC理念，IOC就是控制反转，控制权本来在程序员手上，现在控制权到用户手上。 代码例子： service层要用dao层类的方法，必须new一个dao层类的实例。当需求改变时，接口新的实现类诞生，service层中的类又必须
Spring——IOC + DI功能实现（完全注解开发）
胜天半子祁同伟
06-26 4887
Spring——IOC + DI功能实现（完全注解开发）
spring框架两大核心：IOC和AOP的详解
qq_49755675的博客
07-06 8979
IOC和AOP的详解。
Spring常用注解 使用注解来构造IoC容器的方法
08-28
本文将详细介绍 Spring 框架中常用的注解，并阐述如何使用这些注解来构造 IoC 容器。IoC 容器是 Spring 框架的核心组件之一，它提供了一个强大的依赖注入机制，能够帮助开发者更方便地管理和维护应用程序中的组件。...
Spring注解驱动开发第41讲——Spring IOC容器创建源码解析(一)之BeanFactory的创建以及预准备工作（合起
08-07
Spring注解驱动开发第41讲——Spring IOC容器创建源码解析(一)之BeanFactory的创建以及预准备工作（合起来整个过程）
spring-boot-source:Spring Boot源码分析+注解
03-24
spring-boot-source Spring Boot源码分析1.核心原始主线流程分析2.AutoConfig自动装配过程-Mybatis RabbitMQ Redis等自动装配过程3.Spring Boot与IOC关联4，Spring Boot集成的Tomcat启动流程
springboot与flowable（9）：候选人组
游王子的博客
06-15 275
act_id_xxx相关表存储了所有用户和组的数据。
SpringBoot+Maven项目的配置构建
weixin_72330417的博客
06-15 263
【代码】SpringBoot+Maven项目的配置构建。
Spring 循环依赖详解
Java领域优秀创作者
06-15 885
在Spring框架中，依赖注入（Dependency Injection, DI）是其核心功能之一，它通过配置来管理对象的创建和它们之间的依赖关系。然而，在复杂的应用程序中，开发人员有时会遇到循环依赖的问题，即Bean A依赖于Bean B，而Bean B又依赖于Bean A。如果不加以处理，这种情况会导致应用程序无法启动。在本文中，我们将深入探讨Spring循环依赖的原理、处理机制、最佳实践以及可能遇到的问题。
小白快速入门之SpringBoot面向切面编程（AOP）
最新发布
weixin_42415173的博客
06-18 110
AOP、切面编程、SpringBoot
spring常用注解Ioc
08-08
其中，@Component注解是Spring框架中的基本注解，用于标识一个类为Spring的组件，被该注解修饰的类将被存入Spring的IoC容器中。@Autowired注解用于自动装配Bean，它可以在类成员变量、方法参数、构造函数参数等位置...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值