java框架篇---spring IOC依赖注入

spring依赖注入的方式有4种

  • 构造方法注入
  • 属性注入
  • 工厂注入
  • 注解注入

下面通过一个实例统一讲解:

User.java

package com.bjsxt.model;

public class User {
    private String username;
    private String password;
    public User(){}
    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password + "]";
    }
}

UserDAO.java

package com.bjsxt.dao;
import com.bjsxt.model.User;

public interface UserDAO {
    public void save(User user);
}

UserDAO实现类UserDAOImpl

package com.bjsxt.dao.impl;

import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;

public class UserDAOImpl implements UserDAO {

    public void save(User user) {
        //Hibernate
        //JDBC
        //XML
        //NetWork
        System.out.println("user saved!");
    }

}

工厂类

第一个:UserFactory

package com.bjsxt.factory;

import com.bjsxt.model.User;

public class UserFactory {
    public User CreatUser () {
        User user=new User();
        user.setUsername("周1");
        user.setPassword("oumyye");
        return user;
    }
}

第二个:UserFactory2 

package com.bjsxt.factory;

import com.bjsxt.model.User;

public class UserFactory2 {
    public static User CreatUser () {
        User user=new User();
        user.setUsername("偶my耶1");
        user.setPassword("oumyye");
        return user;
    }
}

控制层:UserService

package com.bjsxt.service;
import com.bjsxt.dao.UserDAO;
import com.bjsxt.model.User;

public class UserService {

    private UserDAO userDAO;  

    public void init() {
        System.out.println("###########init");
    }

    public void save(User user) {
        userDAO.save(user);
    }
    public UserDAO getUserDAO() {
        return userDAO;
    }
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public UserService(UserDAO userDAO) {
        super();
        this.userDAO = userDAO;
    }

    public void destroy() {
        System.out.println("destroy");
    }
}

配置文件:bean.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <!--        构造方法注入 -->
    <bean id="user" class="com.bjsxt.model.User" >
    <constructor-arg index="0" type="String" value="zhou"></constructor-arg>
    <constructor-arg index="1" type="String" value="password"></constructor-arg>
    </bean>

    <!-- 属性注入 -->
    <bean id="user1" class="com.bjsxt.model.User" >
    <property name="username" value="zhang"></property>
    <property name="password" value="oumyye"></property>
    </bean>
    <!-- 工厂注入 -->
    <bean  id= "userFactory" class="com.bjsxt.factory.UserFactory" > </bean>
    <bean id="user2" factory-bean="userFactory" factory-method="CreatUser"></bean>

    <!-- 静态工厂注入 -->
    <bean  id= "user3" class="com.bjsxt.factory.UserFactory2" factory-method="CreatUser"> </bean>

      <bean id="u" class="com.bjsxt.dao.impl.UserDAOImpl"></bean> 

      <bean id="userService" class="com.bjsxt.service.UserService" init-method="init" destroy-method="destroy" scope="prototype">

      <!-- <property name="userDAO" ref="u" /> -->

<!--        构造方法注入 -->
       <constructor-arg>
           <ref bean="u"/>
       </constructor-arg>
  </bean>

</beans>

测试类:

package com.bjsxt.service;

import static org.junit.Assert.*;

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

import com.bjsxt.model.User;

public class UserServiceTest {

    @Test
    public void test() {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("beans.xml");
        UserService userService=(UserService) applicationContext.getBean("userService");
        //构造方法注入
        User user=(User) applicationContext.getBean("user");
        //属性注入
        User user1=(User) applicationContext.getBean("user1");
        //工厂注入
        User user2=(User) applicationContext.getBean("user2");
        //工厂注入
        User user3=(User) applicationContext.getBean("user3");

        System.out.println(user);
        System.out.println(user1);
        System.out.println(user2);
        System.out.println(user3);
        userService.save(user);
        userService.destroy();
    }

}

结果:

###########init
User [username=zhou, password=password]
User [username=zhang, password=oumyye]
User [username=周1, password=oumyye]
User [username=偶my耶1, password=oumyye]
user saved!
destroy

注解方式在后面详细介绍

依赖注入—自动装配

Spring中提供了自动装配依赖对象的机制,但是在实际应用中并不推荐使用自动装配,因为自动装配会产生未知情况,开发人员无法预见最终的装配结果。

自动装配是在配置文件中实现的,如下:

<bean id="***" class="***" autowire="byType">

只需要配置一个autowire属性即可完成自动装配,不用再配置文件中写<property>,但是在类中还是要生成依赖对象的setter方法。

Autowire的属性值有如下几个:

· byType 按类型装配  可以根据属性类型,在容器中寻找该类型匹配的bean,如有多个,则会抛出异常,如果没有找到,则属性值为null;

· byName 按名称装配  可以根据属性的名称在容器中查询与该属性名称相同的bean,如果没有找到,则属性值为null;

· constructor 与byType方式相似,不同之处在与它应用于构造器参数,如果在容器中没有找到与构造器参数类型一致的bean,那么将抛出异常;

· autodetect 通过bean类的自省机制(introspection)来决定是使用constructor还是byType的方式进行自动装配。如果发现默认的构造器,那么将使用byType的方式。

原文地址:https://www.cnblogs.com/jiangzhaowei/p/9629818.html

时间: 2024-11-06 09:48:43

java框架篇---spring IOC依赖注入的相关文章

java框架篇---spring IOC 实现原理

IOC(DI):其实这个Spring架构核心的概念没有这么复杂,更不像有些书上描述的那样晦涩.java程序员都知道:java程序中的每个业务逻辑至少需要两个或以上的对象来协作完成,通常,每个对象在使用他的合作对象时,自己均要使用像new object() 这样的语法来完成合作对象的申请工作.你会发现:对象间的耦合度高了.而IOC的思想是:Spring容器来实现这些相互依赖对象的创建.协调工作.对象只需要关系业务逻辑本身就可以了.从这方面来说,对象如何得到他的协作对象的责任被反转了(IOC.DI)

Spring IoC 依赖注入(二)源码分析

目录 Spring IoC 依赖注入(二)源码分析 1. 依赖注入口 - populateBean 1.1 doCreateBean 1.2 populateBean 2. 手动注入 2.1 相关的类说明 2.2 applyPropertyValues 2.3 BeanDefinitionValueResolver 2.4 依赖检查 2. 自动注入 2.1 那些字段会自动注入 2.2 名称注入 2.3 类型注入 Spring IoC 依赖注入(二)源码分析 本章主要分析 Spring IoC 依

关于Spring IOC (依赖注入)你需要知道的一切

[版权申明]未经博主同意,不允许转载!(请尊重原创,博主保留追究权) http://blog.csdn.net/javazejian/article/details/54561302 出自[zejian的博客] <Spring入门经典>这本书无论对于初学者或者有经验的工程师还是很值一看的,最近花了点时间回顾了Spring的内容,在此顺带记录一下,本篇主要与spring IOC相关 ,这篇博文适合初学者也适合spring有过开发经验的工程师,前者可用于全面了解Spring IOC的知识点,后者且

java框架篇---spring 依赖注入

spring依赖注入的方式有4种 构造方法注入 属性注入 工厂注入 注解注入 下面通过一个实例统一讲解: User.java package com.bjsxt.model; public class User { private String username; private String password; public User(){} public User(String username, String password) { super(); this.username = use

框架学习 Spring之依赖注入DI

依赖注入的方式有四种: 1.Setter注入(属性注入) 2.构造器注入 3.P命名空间注入 4.集合类型值注入 1.Setter注入(属性注入) Employee 员工实体类 package com.spring.pojo; public class Employee { private Integer id; private String name; private Department department; public Integer getId() { return id; } pu

java框架篇---spring AOP 实现原理

什么是AOP AOP(Aspect-OrientedProgramming,面向方面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善.OOP引入封装.继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为的一个集合.当我们需要为分散的对象引入公共行为的时候,OOP则显得无能为力.也就是说,OOP允许你定义从上到下的关系,但并不适合定义从左到右的关系.例如日志功能.日志代码往往水平地散布在所有对象层次中,而与它所散布到的对象的核心功能毫无

java框架篇---spring hibernate整合

在会使用hibernate 和spring框架后 两个框架的整合就变的相当容易了, 为什么要整合Hibernate?1.使用Spring的IOC功能管理SessionFactory对象 LocalSessionFactoryBean2.使用Spring管理Session对象  HibernateTemplate3.使用Spring的功能实现声明式的事务管理 第一步:搭建hibernate环境(包括引入hibernate的jar,包配置数据源,建立类和表的映射),为什么这么做.我觉得hiberna

java框架篇---spring aop两种配置方式

第一种:注解配置AOP 注解配置AOP(使用 AspectJ 类库实现的),大致分为三步: 1. 使用注解@Aspect来定义一个切面,在切面中定义切入点(@Pointcut),通知类型(@Before, @AfterReturning,@After,@AfterThrowing,@Around). 2. 开发需要被拦截的类. 3. 将切面配置到xml中,当然,我们也可以使用自动扫描Bean的方式.这样的话,那就交由Spring AoP容器管理. 另外需要引用 aspectJ 的 jar 包:

java框架spring的依赖注入初步理解

java框架的spring作为整个工程的统领者,可以有效地管理各层的对象,有效的协调运行,当系统西药重构时,可以极大地减少改写代码的量. 依赖注入和控制反转属于同一个概念,在java中当某个类(调用者)需要另一个类(被调用者)的协助时,在以往的程序设计理念中,通常由调用者类创建一个被调用者类的实例(new一个被调用者类),这种new一个对象的方法通常会在java空间中开创一个空间,对java项目整体运行效率会有一定的影响,而且是比较粗鲁的方式.但在spring框架里,创建调用类的工作不再由调用者