Spring IoC 实例

最新推荐文章于 2022-08-21 20:03:02 发布
最新推荐文章于 2022-08-21 20:03:02 发布
阅读量295 收藏 1
点赞数
分类专栏： java 文章标签： spring bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhiguoliu11/article/details/76824805
版权

方式一：配置文件实现Bean实例化和依赖注入

这里写图片描述

BaseDao.java

package com.demo.spring;

public interface BaseDao {

    public void insert();

    public void delete();

    public void update();

    public void select();

}

ObjectUserFactory.java

package com.demo.spring;

public class ObjectUserFactory {

    public UserDao getUserDao() {
        return new UserDao();
    }

}

StaticUserFactory.java

package com.demo.spring;

public class StaticUserFactory {

    public static UserDao getUserDao() {
        return new UserDao();
    }

}

UserDao.java

package com.demo.spring;

public class UserDao implements BaseDao {

    @Override
    public void insert() {
        System.out.println("insert()");
    }

    @Override
    public void delete() {
        System.out.println("delete()");
    }

    @Override
    public void update() {
        System.out.println("update()");
    }

    @Override
    public void select() {
        System.out.println("select()");
    }

}

UserService.java

package com.demo.spring;

public class UserService {

    private UserDao userDao;

    public UserService() {
        super();
    }

    public UserService(UserDao userDao) {
        super();
        this.userDao = userDao;
    }

    public UserDao getUserDao() {
        return userDao;
    }

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

}

applicationContext.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.xsd">

    <!-- 无参构造实例化配置 -->
    <bean id="userDao" class="com.demo.spring.UserDao"></bean>

    <!-- 静态工厂实例化配置 -->
    <bean id="userDaoByStatic" class="com.demo.spring.StaticUserFactory"
        factory-method="getUserDao"></bean>

    <!-- 动态工厂实例化配置 -->
    <bean id="objectUserFactory" class="com.demo.spring.ObjectUserFactory"></bean>
    <bean id="userDaoByObject" factory-bean="objectUserFactory"
        factory-method="getUserDao"></bean>

    <!-- 构造器注入 -->
    <bean id="userServiceByContructor" class="com.demo.spring.UserService">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>

    <!-- Setter注入, 必须有无参构造 -->
    <bean id="userServiceBySetter" class="com.demo.spring.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

</beans>

UserDaoTest.java

package com.demo.test;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.demo.spring.BaseDao;
import com.demo.spring.UserDao;

public class UserDaoTest {
    public ApplicationContext context;

    @Before
    public void init() {
        context = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void test1() {
        System.out.println("--------------无参构造实例化-----------------");
        BaseDao userDao = context.getBean("userDao", BaseDao.class); // 无参构造实例化
        userDao.insert();

        BaseDao userDao1 = context.getBean("userDao", UserDao.class);
        userDao1.delete();

        UserDao userDao2 = context.getBean("userDao", UserDao.class);
        userDao2.update();
    }

    @Test
    public void test2() {
        System.out.println("--------------静态工厂实例化-----------------");
        BaseDao userDao = context.getBean("userDaoByStatic", BaseDao.class);// 静态工厂实例化
        userDao.insert();

        BaseDao userDao1 = context.getBean("userDaoByStatic", UserDao.class);// 静态工厂实例化
        userDao1.delete();

        UserDao userDao2 = context.getBean("userDaoByStatic", UserDao.class);// 静态工厂实例化
        userDao2.update();
    }

    @Test
    public void test3() {
        System.out.println("--------------动态工厂实例化-----------------");
        BaseDao userDao = context.getBean("userDaoByObject", BaseDao.class);// 动态工厂实例化
        userDao.insert();

        BaseDao userDao1 = context.getBean("userDaoByObject", UserDao.class);// 动态工厂实例化
        userDao1.delete();

        UserDao userDao2 = context.getBean("userDaoByObject", UserDao.class);// 动态工厂实例化
        userDao2.update();
    }

}

UserServiceTest.java

package com.demo.test;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.demo.spring.UserService;

public class UserServiceTest {
    public ApplicationContext context;

    @Before
    public void init() {
        context = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void test() {// 构造器注入
        UserService userService = context.getBean("userServiceByContructor", UserService.class);
        userService.getUserDao().insert();

    }

    @Test
    public void test2() {// setter注入，必须有无参构造
        UserService userService = context.getBean("userServiceBySetter", UserService.class);
        userService.getUserDao().delete();
    }

}

pom.xml

<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>com.demo</groupId>
    <artifactId>maven-spring</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>
        <!-- junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- spring核心包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.0.RELEASE</version>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>3.0.1</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

配置文件方式代码源码

方式二：注解方式实现Bean实例化和依赖注入

这里写图片描述

BaseDao.java

package com.demo.spring;

public interface BaseDao {

    public void insert();

    public void delete();

    public void update();

    public void select();

}

UserDao.java

package com.demo.spring;

import org.springframework.stereotype.Repository;

@Repository
public class UserDao implements BaseDao {

    @Override
    public void insert() {
        System.out.println("insert()");
    }

    @Override
    public void delete() {
        System.out.println("delete()");
    }

    @Override
    public void update() {
        System.out.println("update()");
    }

    @Override
    public void select() {
        System.out.println("select()");
    }

}

UserService.java

package com.demo.spring;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    // @Resource // 写在字段前面，可以没有setter方法，默认名称优先
    @Autowired // 写在字段前面，可以没有setter方法，默认类型优先
    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

}

applicationContext.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.xsd">

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

</beans>

UserDaoTest.java

package com.demo.test;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.demo.spring.BaseDao;
import com.demo.spring.UserDao;

public class UserDaoTest {
    public ApplicationContext context;

    @Before
    public void init() {
        context = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void test1() {
        System.out.println("--------------无参构造实例化-----------------");
        BaseDao userDao = context.getBean("userDao", BaseDao.class); // 无参构造实例化
        userDao.insert();

        BaseDao userDao1 = context.getBean("userDao", UserDao.class);
        userDao1.delete();

        UserDao userDao2 = context.getBean("userDao", UserDao.class);
        userDao2.update();
    }

}

UserServiceTest.java

package com.demo.test;

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 com.demo.spring.UserService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:applicationContext.xml" })
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void test() {
        userService.getUserDao().insert();
    }

}

pom.xml

<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>com.demo</groupId>
    <artifactId>maven-spring</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>
        <!-- junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.2.0.RELEASE</version>
            <scope>test</scope>
        </dependency>

        <!-- spring核心包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.0.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>3.0.1</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

注解方式代码源码

zhiguoliu11
关注
专栏目录
Spring的IOC简单实例
马如林的IT博客
11-13 1万+
 编程针对接口比较好，所以Spring的Ioc帮助我们实现这个效果，不需要工厂类了，而且维护等比较爽，不过看代码而不懂spring的则不爽了，其Ioc的原理是使用了java发射机制进行实现的，像hibernate等OR框架都是依赖发射机制的。 下面的是一个简单示例: UserDao接口package com.rx.test.spring.inter;impo
浅谈springioc实例化bean的三个方法
08-29
浅谈Spring IOC实例化Bean的三个方法 Spring IOC（Inversion of Control，控制反转）是Spring Framework中的一种核心机制，用于管理Bean的生命周期。实例化Bean是IOC的核心步骤之一，本文将详细讲解Spring IOC实例...
springIOC实例
04-28
该资源包含了一个springIOC的简单实例代码，简单易懂。
Spring IOC实例
Mr_Newbie的博客
08-18 749
前言 IOC是利用 工厂模式 通过java反射机制实现自动注入，本文主要用普通java工程采用注解的方式进行演示 IOC其实就是创建一个ioc容器，把实例化对象的工作交给spring，利用反射机制自动注入，在执行程序执行之前首先实例化后期要被用到的对象（如service层），存放到ioc容器中，方便我们进行调用和管理。 目录： 一、dao层 GoodDao.java public interface GoodDao { public void sayHello(); } GoodDaoImpl.jav
Spring-IOC实例
09-25
Spring-IOC实例
spring IOC示例
早起的鸟儿有虫吃
06-05 71
今天看了下spring，对于其中的IOC(控制反转)有了一定的认识。使用IOC，对象是被动的接受依赖类，而不是主动的去找，容器在实例化的时候主动将它的依赖类注入给它。可以这样理解：IOC将类的主动权转移到接口上，依赖注入通过配置xml文件在类实例化时将其依赖类注入。 依赖注入：spring中通过依赖注入((Denpendency Injection)来实现IOC,依赖注入有三种实现方式：...
创建Maven项目和Spring IOC实例过程解析
08-25
创建Maven项目和Spring IOC实例过程解析 一、Maven项目创建过程 Maven是一个基于项目对象模型（Project Object Model，POM）的项目管理工具，主要用于管理和构建Java项目。创建Maven项目需要使用IDEA开发工具，并...
通过实例解析Spring Ioc项目实现过程
08-19
Spring Ioc项目实现过程详解 ...通过本文可以了解Spring Ioc项目的实现过程，包括创建Maven项目、创建POJO Java对象、创建Bean XML配置元数据、创建Spring上下文、获取Bean实例等步骤，并了解如何解决常见的错误。
springIOC 实例化bean过程
最新发布
05-19
下面是Spring IOC实例化Bean的过程： 1. 装载Bean配置文件：Spring IOC容器会读取配置文件中的Bean定义，通常使用XML格式的配置文件。 2. 解析Bean定义：容器会解析配置文件中的Bean定义，包括Bean的类型、属性、...
简单的spring ioc例子
风过留痕
10-31 982
spring文件 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="ht
Spring之IOC示例
04-19
NULL 博文链接：https://huangminwen.iteye.com/blog/1041298
简单的springIOC案例
fyphome
09-30 798
设计简单的springIOC案例一、文档介绍1. 模块依赖2. 各模块详细uml图二、代码演示 一、文档介绍 1. 模块依赖 要做好相关准备工作之前，首先要定义好各模块，说的通俗一点，主要有下面4个模块构成： 1.定义bean相关的pojo类 PropertyValue类： PropertyValue通俗来讲是单个bean下的单个property标签，存放该标签中的属性值，例如下图中PropertyValue存放了property标签中的各属性值（name、ref或者value） <be
Spring IOC 代码实例
春风化雨
01-07 508
1、IOC测试类 package com.ioc; import org.springframework.context.annotation.AnnotationConfigApplicationContext; public class IocTest { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigAp
Spring初学快速入门
weixin_33674976的博客
07-10 198
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring(一)IOC小案例
a910247的博客
06-11 214
大家好呀，今天跟大家分享一个IOC容器小案例，希望对大家有所帮助哦！喜欢记得点个关注哦，更多精彩等你哦。一、首先我们来创建一个service层包，在包中再建一个UserService类. 二、然后在建一个dao包，在包中分别建一个UserDao接口类和继承接口的UserDaoiml类。 三、接下来就是在xml文件中配置相应的数据咯 四、最后当然是建立一个测试类啦。...
Spring IOC入门案例
爱吃饭的博客
06-08 150
IOC
（一）Spring 之IOC入门简单例子
热门推荐
ZJE
01-20 1万+
1. IOC 和 DI 是什么 2.导入Spring 的jar 包 3.实现IOC简单例子的步骤 （一）IOC 和 DI是什么 IOC即控制反转，意思是对象的创建不通过 手动 new，而是把对象的创建权交给Spring来完成。 DI 即依赖注入，意思是 Spring主动创建被调用类的对象，然后把这个对象注入到我们自己的类中，使我们能使用它 （二）导入jar 包 下载s
Spring-IOC入门案例
汤键的博客
08-21 349
Spring-IOC入门案例
spring IoC——注入bean实例
Bruce_Json的博客
08-25 633
在spring中IoC容器占据了很核心的功能，通过IoC容器可以完全 管理java Bean ，包括创建，销毁，还可以对数据库的java Bean进行自动化的事务处理，IoC的容器是实现了BeanFctory接口的实现类，ApplicationContext是BeanFactory的子接口，BeanFactory接口提供了最基本的对象管理功能，子接口AplicationContext提供了更多的功...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值