Spring注入(IOC):

简单来说就是减少层与层之间的耦合关系,本来在service调用dao要new,有了这个就可以通过注入的方式,相当与把所有的new操作都变成了在配置文件中配置,有改动时直接改配置就行了不用一个个java文件去改。

1.搭建web项目,导入spring核心包。copy到web目录lib即可。

项目的构成:

1.首先是创建一个bean。省略setter、getter

public class UserBean{
    private String userName;
    private int age;
    private Date birthday;
    private double salary;
}

建立spring的配置文件application.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx.xsd">

    <import resource="application2.xml"/>
    <bean id="UserBean" class="pojo.UserBean" scope="singleton" lazy-init="true">
        <!--     singleton – 单例模式 ,即整个应用只有一个实例 。适合于服务 bean 和Dao Bean。单例模式的对象实例在容器启动时候就会创建。
?                    Prototype – 原型模式,即每次请求都创建一个对象。适合于action bean。原型模式的对象在请求对象时候创建
                    lazy-init - 懒加载,默认=false,启动就创建(不懒),true就是懒加载
            -->
        <property name="userName" value="zs"></property>
        <property name="age" value="18"></property>
        <property name="birthday">
            <bean class="java.util.Date"></bean>
        </property>
        <property name="salary" value="9000.33"></property>
    </bean>

</beans>

单元测试,通过配置文件获得创建的对象。两种方式获得。都能打印出结果。

public class UserBeanTest {

    @Test
    public void test() {
        //启动spring 容器,指定配置文件。
        ApplicationContext ctx=new ClassPathXmlApplicationContext("application.xml");
        //通过容器获取UserBean对象
        UserBean bean=(UserBean) ctx.getBean("UserBean");
        System.out.println(bean.toString());
    }
    @Test
    public void testByFactory(){
        //通过工厂类得到bean对象
        Resource resource= new ClassPathResource("application.xml");
        BeanFactory factory=new XmlBeanFactory(resource);
        //通过容器获取UserBean对象
        UserBean bean=(UserBean) factory.getBean("UserBean");
        System.out.println(bean.toString());
    }

}

结果:

UserBean [userName=zs, age=18, birthday=Wed Sep 13 16:37:20 CST 2017, salary=9000.33]

2.对象的注入。

新建dao和impl

public interface UserDao {
    public abstract void print();

}

----------------------------------------------------------------------------------------
public class UserDaoImpl implements UserDao {
    @Override
    public void print() {
        System.out.println("dao打印:");
    }

}

新建service和impl

public interface UserService {
    public abstract void print();

}

-------------------------------------------------------------------------------------------
public class UserServiceImpl implements UserService {
    //要注入它
    UserDao dao;
    @Override
    public void print() {
        dao.print();
    }
    public UserDao getDao() {
        return dao;
    }
    public void setDao(UserDao dao) {
        this.dao = dao;
    }

}

建立配置文件2号

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    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
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- set注入:对应在服务层调用dao给它setter、getter -->
    <bean id="dao" class="dao.impl.UserDaoImpl"></bean>
    <bean id="service" class="service.impl.UserServiceImpl">
        <property name="dao" ref="dao"></property>
    </bean>

    <!-- 内部bean方式,也要setter、getter -->
    <bean id="service2" class="service.impl.UserServiceImpl">
        <property name="dao">
            <bean class="dao.impl.UserDaoImpl"></bean>
        </property>
    </bean>    

    <!--P:命名空间注入属性值 也要setter、getter,跟set注入一样的,就是减少了property的数量。p:dao-ref="dao" 中的‘dao‘换为对应的注入对象即可-->
    <bean id="service3" class="service.impl.UserServiceImpl" p:dao-ref="dao"></bean>

    <!--自动注入(autowire)  -->
    <bean id="service4" class="service.impl.UserServiceImpl" autowire="byName"></bean>
    <!--?Aotowire=byType:根据名称属性类型自动进行注入。  -->
    <bean id="service5" class="service.impl.UserServiceImpl" autowire="byType"></bean>

</beans>

在原来的配置文件中加上import把两个连接起来。

<import resource="application2.xml"/>

单元测试。

public class 各种注入方式 {

    @Test
    public void test() { //set注入
        /** application.xml 要import */
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("application.xml");
        /** 合并的写法 */
//        ApplicationContext applicationContext=new ClassPathXmlApplicationContext(new String[]{"application.xml","application2.xml"});
        UserService service= (UserService) applicationContext.getBean("service");
        service.print();
    }
    @Test
    public void test2() { //内部bean
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("application.xml");
        UserService service= (UserService) applicationContext.getBean("service2");
        service.print();
    }
    @Test
    public void test3() { //命名空间注入
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("application.xml");
        UserService service= (UserService) applicationContext.getBean("service3");
        service.print();
    }
    @Test
    public void test4() { //按照名字自动注入
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("application.xml");
        UserService service= (UserService) applicationContext.getBean("service4");
        service.print();
    }
    @Test
    public void test5() { //按照类型自动注入
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("application.xml");
        UserService service= (UserService) applicationContext.getBean("service5");
        service.print();
    }
    @Test
    public void test6() { //获取bean的另一个写法,会自动在配置文件中找对应的class类型匹配,但是配置文件里面自能有一个对应的类,多了也错
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("application.xml");
        UserService service= (UserService) applicationContext.getBean(UserService.class);
        service.print();
    }

}

test6这种获取bean的方式要只有一个才可以,很多个bean都是一样的,仅仅是id不同会报错的。

3.注解方式。

时间: 09-15

Spring注入(IOC):的相关文章

Spring注入,Ioc的具体配置

Spring框架的IOC注入: 一.Java部分代码: Person实体类: 1 package com.ioc; 2 3 import java.util.List; 4 import java.util.Map; 5 import java.util.Properties; 6 import java.util.Set; 7 8 import com.adviceAop.Dancer; 9 import com.aop.Singer; 10 11 /** 12 * Spring 各种类型的注

Spring之IOC容器注入

上一篇做了IOC和AOP的原理介绍,这一篇主要讲解IOC的注入.不过我依然困惑一个问题: 一 : 依赖注入(DI)中有三种注入方式,那Spring中到底实现了几种方式?也是三种? IOC在很多框架中都有实现,并不是Spring特有的,之前说过IOC主要包含DL(Dependency Lookup)和DI(Dependency Injection),也就是说实现IOC的技术有很多,但是主要包含DI和DL,但是相对而言,DI应用范围比较广泛,我想这也是为什么Martin Fowler将控制反转用依赖

Spring控制反转与依赖注入(IOC、DI)

IOC: 反转控制   Inverse Of Control DI:依赖注入 Dependency Injection 目的:完成程序的解耦合 解释:在应用系统的开发过程中,有spring负责对象的创建,对象依赖关系的组装,对象属性的初始化,程序员只需要在程序接收spring创建的对象即可. Object obj= new Object(); IOC :  Object obj;  等着接收spring容器创建好的对象,在程序中将对象的创建的权限交出,反转到spring容器中. DI:  某个对

Spring.net Ioc 依赖注入

控制反转 (Inversion of Control,英文缩写为IoC)是一个重要的面向对象编程的法则来削减计算机程序的耦合问题,也是轻量级的Spring框架的核心. 控制反转一般分为两种类型,依赖注入(Dependency Injection,简称DI)和依赖查找(Dependency Lookup). Spring.NET 为建立企业级应用提供了一套轻量级的解决方案.通过Spring.NET,我们可以用统一且透明的方式来配置应用程序.Spring.NET的重点是为中间层提供声明式事务管理,以

Spring的IOC容器—依赖注入

前面一篇博客大致讲了一下Spring的IOC容器的原理,IOC即控制反转主要是依靠依赖注入的方式来实现的.依赖注入是指所依赖的对象不是由自己new出来的,而是用别的方式像打针似的注入进来. 其实说白了不管是控制反转还是依赖注入都说明了Spring采用动态.灵活的方式来管理各种对象. Spring的依赖注入对调用者和被调用者几乎没有任何要求,完全支持对POJO之间依赖关系的管理.有以下几种注入方式: 1. Setter 注入 因为对于javaBean来说,我们可以通过setter和getter方法

Spring之IOC/DI(反转控制/依赖注入)_入门Demo

软件152 刘安民 在平时的java应用开发中,我们要实现某一个功能或者说是完成某个业务逻辑时至少需要两个或以上的对象来协作完成,在没有使用Spring的时候,每个对象在需要使用他的合作对象时,自己均要使用像new object() 这样的语法来将合作对象创建出来,这个合作对象是由自己主动创建出来的,创建合作对象的主动权在自己手上,自己需要哪个合作对象,就主动去创建,创建合作对象的主动权和创建时机是由自己把控的,而这样就会使得对象间的耦合度高了,A对象需要使用合作对象B来共同完成一件事,A要使用

【Spring】Spring依赖注入IOC的设值注入setter

其实标题中如此高大上的名词,只是一个问题,关于在Spring的applicationContext.xml中的如下语句是什么意思? <property name="aService" ref="aService"/> 这类语句在SSH的配置中会大量存在,因为Spring所谓的核心机制就是Spring依赖注入IOC.下面举一个例子说明这个问题: 先贴上目录结构: 在Eclipse中新建一个Java工程,不是JavaWeb,在这个Java配置好Spring3

spring中IOC的简单使用

spring的ioc主要就是依赖注入,有基于构造器的依赖注入还有通过设值注入,这里我只简单的实现设值注入的方法,通过spring的依赖管理,我们可以很方便的了解各层之间的依赖关系,降低了各层之间的耦合,我们可以不用过多的去关注对象的管理和创建,我们只需要去bean工厂申请即可,这样我们更多的注意力就可以放到真正的代码实现,而不用去关心代码的创建和销毁.,接下来时简单的设值注入. 我们先简单的去创建一个学生类和老师类 public class Student { public void outhi

Spring的Ioc

引用:http://www.cnblogs.com/xdp-gacl/p/4249939.html 学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解. 一.分享Iteye的开涛对Ioc的精彩讲解 首先要分享的是Iteye的开涛这位技术牛人对Spring框

一点一点学架构(三)——Spring.NET IOC

IOC背景介绍 传统的实现: 由程序内部代码来控制类与类之间的关系(如:在一个具体的类中,调用另一个类的方法). 使用new关键字来实现两个类之间关系的组合. 这种实现方式会造成类之间耦合. IOC的实现: 它将类间关系从程序内部提到外部容器,也就是说由容器在运行期将类间的某种依赖关系动态注入类中. 对象A依赖于对象B,当对象 A需要用到对象B的时候,IOC容器就会立即创建一个对象B送给对象A. IOC容器就是一个对象制造工厂,你需要什么,它会给你送去,你直接使用就行了,而再也不用去关心你所用的