深入浅出Spring IOC-4

最新推荐文章于 2023-10-21 21:44:30 发布
最新推荐文章于 2023-10-21 21:44:30 发布
阅读量225 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovezhaohaimig/article/details/80398207
版权


前言：


今天我们来学习实际开发中经常会使用到的IOC技术：通过IOC容器架构程序的分层。

实现有两种方式：基于xml配置文件，基于注解。


思路：

我们把程序分为3层：Controller层，Service层，DAO层。

关系为Controller层调用Service层，Service层调用DAO层，并且Service层和DAO层设计为接口，这是一个典型的MVC模式后台代码分层结构。

代码：


基于xml配置方式：


1.创建UserController类。  


public class UserController {

    private UserService userService;

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public User getUserById(int id){
        return userService.getUserById(id);
    }
}


2.创建UserService接口以及实现类UserServiceImpl。


public interface UserService {
    public User getUserById(int id);
}


public class UserServiceImpl implements UserService{

    private UserDAO userDAO;

    public UserDAO getUserDAO() {
        return userDAO;
    }

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    @Override
    public User getUserById(int id) {
        // TODO Auto-generated method stub
        return userDAO.getUserById(id);
    }

}


3.创建UserDAO接口以及实现类UserDAOImpl。


public interface UserDAO {
    public User getUserById(int id);
}


public class UserDAOImpl implements UserDAO{

    private static Map<Integer,User> users;

    static{
        users = new HashMap<Integer,User>();
        users.put(1, new User(1, "张三"));
        users.put(2, new User(2, "李四"));
        users.put(3, new User(3, "王五"));
    }

    @Override
    public User getUserById(int id) {
        // TODO Auto-generated method stub
        return users.get(id);
    }

}


4.创建User实体类。


public class User {
    private int id;
    private String name;
    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 User(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public User() {
        super();
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }

}


5.在spring.xml配置userController，userService，userDAO，并完成依赖注入。


<?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">

    <!-- 配置UserController -->
    <bean id="userController" class="com.southwind.controller.UserController">
        <property name="userService" ref="userService"></property>
    </bean>

    <!-- 配置UserService -->
    <bean id="userService" class="com.southwind.service.impl.UserServiceImpl">
        <property name="userDAO" ref="userDAO"></property>
    </bean>

    <!-- 配置UserDAO -->
    <bean id="userDAO" class="com.southwind.dao.impl.UserDAOImpl"></bean>


</beans>


6.在测试类中获取userController对象，调用方法获取user对象。


public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserController userController = (UserController) applicationContext.getBean("userController");
        User user = userController.getUserById(1);
        System.out.println(user);
    }
}




基于注解的方式：

第一步：将UserController，UserService，UserDAO类扫描到IOC容器中。

第二步：在类中设置注解完成依赖注入。


1.修改spring.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 http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 将类扫描到IOC容器中 -->
    <context:component-scan base-package="com.southwind"></context:component-scan>

</beans>


base-package="com.southwind"表示将com.southwind下所有子包的类全部扫描到IOC容器中，一步可将所有参与项目的类完成扫描注入。


注意：需要引入context命名空间。


2.修改UserController，添加注解。


@Controller
public class UserController {

    @Autowired
    private UserService userService;

    public User getUserById(int id){
        return userService.getUserById(id);
    }
}


对比之前的代码，有两处改动：

（1）在类名处添加@Controller注解，表示该类作为一个控制器。

（2）userService属性出添加@Autowired注解，表示IOC容器自动完成装载，默认是byType的方式。


3.修改UserServiceImpl。


@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserDAO userDAO;

    @Override
    public User getUserById(int id) {
        // TODO Auto-generated method stub
        return userDAO.getUserById(id);
    }

}


同上，做了两处改动：

（1）在类名处添加@Service注解，表示该类是业务层。

（2）userDAO属性出添加@Autowired注解，表示IOC容器自动完成装载，默认是byType的方式。


4.修改UserDAOImpl。


@Repository
public class UserDAOImpl implements UserDAO{

    private static Map<Integer,User> users;

    static{
        users = new HashMap<Integer,User>();
        users.put(1, new User(1, "张三"));
        users.put(2, new User(2, "李四"));
        users.put(3, new User(3, "王五"));
    }

    @Override
    public User getUserById(int id) {
        // TODO Auto-generated method stub
        return users.get(id);
    }

}


做了一处改动：在类名处添加@Repository注解，表示该类是数据接口层。

    

5.运行测试代码。


public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserController userController = (UserController) applicationContext.getBean("userController");
        User user = userController.getUserById(1);
        System.out.println(user);
    }
}




成功，通过代码可以看到，使用注解的方式，可简化代码，所以实际开发中，推荐使用基于注解的方式来架构分层。


我们分别给UserController，UserService，UserDAO添加了@Controller，@Service，@Repository注解。

IOC中可以给类添加的注解有4种：

1.@Controller  

2.@Service

3.@Repository

4.@Component


这四种注解方式没有区别，我们在开发时可以随意使用任意一个注解，但是基于代码规范我们一般选择使用@Controller，@Service，@Repository分别表示Controller层，Service层，DAO层。


前面我们提到过，类中属性自动装载，默认是通过byType的方式。

自动装载除了byType的方式，还可以使用byName的方式，使用byName的方式，需要结合@Qualifier注解一起使用。


@Controller
public class UserController {

    @Autowired()
    @Qualifier("userService")
    private UserService userService;

    public User getUserById(int id){
        return userService.getUserById(id);
    }
}


我们知道byName的方式，是通过属性名去匹配对应bean的id属性值，但是基于注解的方式我们并没有给bean设置id，如何完成呢？

其实我们在类中添加注解时，已经设置了默认的id，即类名首字母小写之后的值就是id的默认值。


@Service
public class UserServiceImpl implements UserService


此时，IOC容器中默认赋值，UserService bean的id=userService，与UserController中的属性名一致，所以可以完成自动。


现在做出修改，手动赋值，设置UserService bean的id=myUserService。


@Service("myUserService")
public class UserServiceImpl implements UserService{

    @Autowired
    private UserDAO userDAO;

    @Override
    public User getUserById(int id) {
        // TODO Auto-generated method stub
        return userDAO.getUserById(id);
    }

}


很显然，UserController中的userService属性也需要去匹配name=myUserService的bean，所以设置@Qualifier（"myUserService"）。


@Controller
public class UserController {

    @Autowired()
    @Qualifier("myUserService")
    private UserService userService;

    public User getUserById(int id){
        return userService.getUserById(id);
    }
}


@Qualifier（）中的值必须与@Service（）中的值一致，才能完成自动装载。



源码：


链接: https://pan.baidu.com/s/1sm73sJV

密码: petf

lovezhaohaimig
关注
专栏目录
Spring深入浅出(二)IOC详解
夏风
01-25 6812
IOC即inverse of control 控制反转 以前对象之间的引用是通过new来调用实现，有了Spring IOC,我们可以把对象之间的引用交给他来管理，这样就把控制权交给了Spring，所以就叫做控制反转。 Spring IOC的实现用到了设计模式：简单工厂，他也是从简单工厂进化而来的，下面我们看看Spring的IOC是如何进化来的。 简单工厂模式实现：package org;
Spring深入浅出（一）IOC的基本知识
weixin_30677073的博客
08-30 72
Spring前言 Spring是一个企业级开发框架，为解决企业级项目开发过于复杂而创建的，框架的主要优势之一就是分层架构，允许开发者自主选择组件。 Spring的两大核心机制是IOC（控制反转）和AOP（面向切面编程），从开发的角度讲，我们使用Spring框架就是用它的IOC和AOP。 IOC是典型的工厂模式，通过工厂去注入对象。 AOP则是代理模式的体现。 IOC控制反转 ...
spring核心思想之IOC深入浅出介绍
学而时习
05-30 1292
spring核心思想之IOC深入浅出介绍 一.依赖倒置原则 要了解控制反转( Inversion of Control ), 我觉得有必要先了解软件设计的一个重要思想：依赖倒置原则（Dependency Inversion Principle ）。 什么是依赖倒置原则？假设我们设计一辆汽车：先设计轮子，然后根据轮子大小设计底盘，接着根据底盘设计车身，最后根据车身设计好整个汽车。这里就出现了一个“依赖”关系：汽车依赖车身，车身依赖底盘，底盘依赖轮子。这样的设计看起来没问题，但是可维护性却很低。假设设计完工之
深入浅出Spring IOC-1
lovezhaohaimig的博客
05-21 226
前言：Spring是一个企业级开发框架，为解决企业级项目开发过于复杂而创建的，框架的主要优势之一就是分层架构，允许开发者自主选择组件。Spring的两大核心机制是IOC（控制反转）和AOP（面向切面编程），从开发的角度讲，我们使用Spring框架就是用它的IOC和AOP。IOC是典型的工厂模式，通过工厂去注入对象。AOP则是代理模式的体现。今天我们来详细了解IOC，IOC是Spring框架的灵魂，...
深入浅出Spring IOC-3
lovezhaohaimig的博客
05-22 136
今天我们继续来学习IOC的两个知识点。1.IOC通过工厂方法创建对象2.IOC自动装载（autowire）代码：IOC通过工厂方法创建对象我们之前说过IOC是典型的工厂模式，今天我们就来学习如何使用工厂模式来创建bean。IOC通过工厂模式创建bean有两种方式：1.静态工厂方法2.实例工厂方法按照惯例，我们还是通过代码来带大家去学习工厂方法。首先来学习静态工厂方法。1.创建Car实体类publi...
深入浅出Spring IOC-2
lovezhaohaimig的博客
05-21 217
前言：上一篇文章我们介绍了Spring的IOC，即控制反转，Spring来创建对象，程序中需要使用对象时，直接通过Spring容器来获取对象，并通过DI完成对象之间的注入关系。今天我们继续来学习IOC的相关知识。代码：1.Spring中的bean是根据scope来生成的，表示bean的作用域。scope有4种类型：1.singleton：单例，表示通过Spring容器获取的该对象是唯一的。2.pr...
【Spring-IOC基础】深入浅出Spring-IOC
热门推荐
ATFWUS的博客
04-20 4万+
IOC（Inversion Of Control） 1.概念： 控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统...
Spring IOC 深入浅出
weixin_42274285的博客
05-03 850
Spring IOC 深入浅出
深入浅出讲解Spring IOC和DI的区别
最新发布
小电玩
10-21 831
很多人都会把ioc和di说成同一个东西，其实IOC和DI虽然在概念上可以笼统地视为同一事物，但其本质上存在区别。IOC（Inverse of Control，控制反转）从容器的角度描述，而DI（Dependency Injection，依赖注入）则从应用程序的角度描述。换言之，IOC是依赖倒置原则的设计思想，而DI则是该原则的具体实现方式。因此，我们希望能够更加严谨地区分这两个概念，以更好地理解和应用它们。
深入浅出学spring
05-21
《深入浅出学Spring》这一教学视频为Spring框架的学习提供了详尽且易懂的指导，尤其适合初学者。Spring框架是Java平台上的一个开源框架，它提供了一种全面的基础架构支持，让Java开发者能够开发出更为简洁、高效的...
Spring深入浅出教程.doc
11-21
本教程将深入浅出地介绍Spring的主要特性、基本实例以及如何搭建和测试环境。 1. 依赖注入与控制反转 依赖注入是Spring的核心机制，它允许在运行时由外部容器（如Spring的ApplicationContext）动态地向组件提供其...
深入浅出Spring Boot 2.x（三）
翔翔的博客
02-01 332
第3章 全注解下的Spring loC IoC是一种通过描述来生成或者获取对象的技术 IoC容器 在Spring中，需要管理的对象称为Spring Bean（简称Bean），管理这些Bean的容器称为 Spring IoC容器（或简称IoC容器）。IoC容器需要具备两个基本的功能： 通过描述管理Bean，包括发布和获取Bean 通过描述完成Bean之间的依赖关系 3.1 IoC容器简介 Spring IoC容器是一个管理Bean的容器，需要实现接口BeanFactory（一个顶级容器接口） BeanF
深入浅出Spring 框架，原来以前白学了
a58125584s的博客
05-10 266
1. 为啥要用 Spring 张三是一个编程小白，他每次在 service 层写代码都要自己 new 一堆 Dao 接口的实现类。 public class ProjectServiceImpl implements ProjectService { UserDao userDao = new UserDaoImpl(); ProjectSectionDao projectSessionDao = new ProjectSessionDaoImpl(); ProjectDao
spring @component 详解
lovezhaohaimig的博客
11-08 6184
1、@controller 控制器（注入服务） 2、@service 服务（注入dao） 3、@repository dao（实现dao访问） 4、@component （把普通pojo实例化到spring容器中，相当于配置文件中的） @Component,@Service,@Controller,@Repository注解的类，并把这些类纳入进spring容器中管理。 下面写这个是引入co
配置c3po数据
lovezhaohaimig的博客
10-09 1038
1.db.properties的配置 jdbc.user=root jdbc.password=root jdbc.driverClass=com.mysql.jdbc.Driver jdbc.jdbcUrl=jdbc:mysql:///spring jdbc.initPoolSize=5 jdbc.maxPoolSize=10 2.applicationContext.xml的
spring加载外置配置文件
lovezhaohaimig的博客
10-01 755
1.在配置文件中加入如下配置:
Spring restTemplate post请求
lovezhaohaimig的博客
09-06 677
第一种方式 K=V public String getTokenValue(){ String tokenValue = ""; String appSecret= "1ea3aaa468d616694465ee2b924fd2a0"; String appId = "ext-hjy"; String prefix = "Bearer " ; MultiValueMap&...
Spring_00600_IOC_annotation_Components
lovezhaohaimig的博客
07-30 317
Spring
深入浅出Spring框架：从IoC到AOP
作者通过一系列章节详细介绍了Spring的IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）的基础与实践，以及资源管理、表达式语言（SpEL）和面向切面编程（AOP）的应用。 在IoC部分，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值