spring的依赖注入

spring的功能和地位在javaweb开发里面我就不多说了，spring为企业级别开发提供了丰富的功能，但是这些功能的底层都是依赖2个核心特性，第一个就是spring的依赖注入（ioc），第二是面向切面（aop），我现在就简单说一下我了解的依赖注入。

当我们调用一个类里面的方法，必须先new一个这个类的实例，然后通过这个实例来调用方法，spring的依赖注入让程序不负责对象的创建和维护，而是将对象的创建工作放到ioc容器里面进行创建来个实例。

package com.spring.ioc.example;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.mstf.bean.User;
import com.mstf.util.ApplicationContextHelper;

public class IOCtest {



public static void main(String[] args) {

    /*ApplicationContextHelper app =null;
    ApplicationContext context1 = new ClassPathXmlApplicationContext("applicationContext.xml"); 

    app.setApplicationContext(context1);


     BeanFactory factory1 =app.getApplicationContext();

     User user1 = (User) factory1.getBean("user");


     System.out.println(user1.getUsername());*/



    //这个利用ioc容器里面去拿
     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");    
     BeanFactory factory = context;    

    User user =  (User) factory.getBean("user");

    SessionFactory sessionFactory = (SessionFactory) factory.getBean("sessionFactory");
    Session session = sessionFactory.openSession();

    Transaction transaction = session.beginTransaction();

    Query query = session.createQuery("from User");

    List<User> users = query.list();

    for (User user5 : users) {

        System.out.println(user5.toString());

    }

     System.out.println(user.getUsername());     

  //传统方式去获取


     User user2 = new User();


     user2.setUsername("jiangtest");


     System.out.println(user2.getUsername());




}


}

applicationcontenxt.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"
    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-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <!-- 数据库的连接信息，使用的是数据源的方式jdbc/dbcp/c3p0 -->
    <!-- 配置数据源，将数据源交给spring容器管理 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
        destroy-method="close">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/one" />
        <property name="user" value="root" />
        <property name="password" value="123" />
        <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
        <property name="initialPoolSize" value="1" />
        <!--连接池中保留的最小连接数。 -->
        <property name="minPoolSize" value="1" />
        <!--连接池中保留的最大连接数。Default: 15 -->
        <property name="maxPoolSize" value="300" />
        <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
        <property name="maxIdleTime" value="60" />
        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
        <property name="acquireIncrement" value="5" />
        <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
        <property name="idleConnectionTestPeriod" value="60" />
    </bean>

    <!-- 注解扫描包 -->
    <context:component-scan base-package="com.mstf" />

    <!-- 配置sessionFactory 工厂 -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 引入hibernate的主配置文件 -->
        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
    </bean>

    <!-- 配置事物 -->
    <!-- 定义一个事物管理器 -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 定义一个切面来进行事物管理 -->
    <tx:advice id="personTransaction" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED" />
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut expression="execution(* com.mstf.service..*.*(..))"
            id="personPontCut" />
        <aop:advisor advice-ref="personTransaction" pointcut-ref="personPontCut" />
    </aop:config>

    <!-- 将业务层交给spring容器来管理 -->
    <bean id="infoServiceImpl" class="com.mstf.service.impl.InfoServiceImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!--将action交给spring容器来管理 -->
    <bean id="infoAction" class="com.mstf.action.InfoAction">
        <property name="infoService" ref="infoServiceImpl" />
    </bean>

    <!-- 将业务层交给spring容器来管理 -->
    <bean id="userServiceImpl" class="com.mstf.service.impl.UserServiceImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!--将action交给spring容器来管理 --> 
    <bean id="userAction" class="com.mstf.action.UserAction">
        <property name="userService" ref="userServiceImpl" />
    </bean>

    <bean id="user" class="com.mstf.bean.User">
        <property name="username" value="jiang"/>
    </bean>

<!--    <bean id="connectAction" class="com.mstf.bean.Connector">


        <property name="urlLab" value="http://192.168.2.151:8080/elws/services/openlab"/>
        <property name="urlAuth" value="http://192.168.2.151:8080/elws/services/authapi"/>

    </bean> -->

</beans>

上面就是一种从数据库获取一种直接从xml文件里面获取。

依赖注入的方式有两种，
1.设值注入：设值注入是指 IoC 容器使用属性的 setting 方法来注入被依赖的实例。
2.构造注入：在构造实例时，已为其完成了依赖关系的初始化。这种利用构造器来设置依赖关系的方式，被称为构造注入。

接下来我会分别介绍着两种方式。