spring介绍;安装;使用

介绍

spring是一个轻量级的Java 开发框架。实现了 高内聚，低耦合；支持AOP(面向切面),控制反转(IOC)也叫依赖注入(Dependency lnjection),声明事务 整合其它ORM框架 等

IOC，控制反转(依赖注入,依赖查找)： 应用自己不负责依赖对象的建立及维护,依赖对象的建立及维护是由外部容器负责的，控制权就由应用转移到了外部容器，控制权的转移就是控制反转。

依赖注入(Dependency lnjection) 在运行期间，由外部容器动态的将依赖对象注入到组件中

 bean:全部的实例,对象 在IOC容器中都能称之为bean

Spring主要的优势
1.低侵入式设计，代码的污染率。
2.控制反转（Ioc）机制，也叫依赖注入（DI），下降了业务对象替换的复杂性，提升了组件之间的解耦。
3.面向切面（AOP），容许将一些通用的任务如安全、事务、日志等进行集中式处理，从而提供了更好的复用。
4.Spring的ORM 和 DAO 提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问。
5.独立于各类应用服务器，基于Spring框架的应用程序，能够实现Write Once,Run Anywhere的承诺。
6.Spring并不强制应用彻底依赖于Spring，开发者可自由选用Spring框架的部分或所有

在pom.xml中 添加 maven依赖

<dependencies>
     <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        </dependency>
    <dependency>  
            <groupId>commons-logging</groupId>  
            <artifactId>commons-logging</artifactId>  
            <version>1.2</version>  
    </dependency>
</dependencies>

spring配置模板

<?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">
<!-- spring配置文件 -->
    <bean id="方法名" class="包名.类名"></bean>
</beans>

 实例化spring容器
Spring的配置文件能够指定多个，经过string数组传入

1.在类路径下寻找配置来实例化容器
AppplicationContext context = new ClassPathXmlApplicationContext(new String[]{"beans.xml"});

2.在文件系统路径下寻找配置文件来实例化容器
ApplicationContext ctx = new FileSystemXmlApplicationContext(new String[]{"d:\\beans.xml"});

 

实例化bean
1.使用类构造器实例化
<bean id="carService" class="com.serviceImpl.CarServiceBean"></bean>

2.使用静态工厂方法实例化
<bean id="carService2" class="test.CarServiceBeanFactory" factory-method="createCarBean"></bean>

public class CarServiceBeanFactory {
    public static CarServiceBean createCarBean(){
        return new CarServiceBean();
    }
}
3.使用实例化工厂方法实例化
<bean id="carService" class="test.CarServiceBeanFactory"></bean>
<bean id="carService3" factory-bean="carService" factory-method="createCarBean2"></bean>
    
public class CarServiceBeanFactory {
    public CarServiceBean createCarBean2(){
        return new CarServiceBean();
    }
}

 

在每一个spring IOC容器中一个bean定义只有一个对象实例。默认状况下会在容器启动初始化bean，
但能够指定bean节点lazy-init="true"延迟初始化bean,这时 只有第一次获取bean会初始化bean
若是想对全部bean都启用应用延迟初始化,可在根节点bean设置 default-lazy-init="true"

 

bean做用域

singleton	(单例模式，默认) 在整个springIOC容器中，使用singleton定义的bean将只有一个实例
prototype	原形模式，每次经过容器的getBean方法获取prototype定义的bean，都会产生一个新的bean实例
request	对于每次HTTP请求，使用request定义的Bean都将产生一个新的实例，每次HTTP请求都将产生不一样的Bean实例,该做用域仅在给予web的Spring ApplicationContext情形下有效
session	对于每次HTTP Session ,使用session定义的Bean都将产生一个新实例，该做用域仅在给予web的Spring ApplicationContext情形下有效
global session	每一个全局得HTTP Session对应一个Bean实例，该做用域仅在给予web的Spring ApplicationContext情形下有效

 

spring依赖注入方式：set注入，构造器注入，静态工厂注入，实例工厂注入 （只写用的最多的注入方式）
　set注入:

package com.dao;

public interface CarDao {
    public void append(String arg);
}

CarDao

package com.dao.Impl;

import com.dao.CarDao;

public class CarDaoImpl implements CarDao {
    //数据库保存操做层
    public void append(String args) {
        System.out.println("CarDaoImpl"+args);
    }

}

CarDaoImpl

package com.service;

public interface CarService {
    public void add(String args);
}

CarService

package com.serviceImpl;

import com.dao.CarDao;
import com.service.CarService;

public class CarServiceImpl implements CarService {
    private CarDao carDao;
    
    public CarDao getCarDao() {
        return carDao;
    }
    //注入
    public void setCarDao(CarDao carDao) {
        this.carDao = carDao;
    }
    
    @Override
    public void add(String args) {
        // 业务操做层
        System.out.println("CarServiceImpl"+args);
        args = args+":"+this.hashCode();
        carDao.append(args);
    }

}

CarServiceImpl

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.service.CarService;

public class RunTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        CarService carService = (CarService) context.getBean("carServer");
        carService.add("test");
        
    }
}

RunTest

<?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">
    
      <bean id="carServer" class="com.serviceImpl.CarServiceImpl">
          <property name="carDao" ref="carBean"></property>
      </bean>
    
    <bean id = "carBean" class="com.dao.Impl.CarDaoImpl"></bean>

</beans>

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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    
      <bean id="carServer" class="com.serviceImpl.CarServiceImpl">
          <constructor-arg name="carDao" ref="carBean"></constructor-arg>
      </bean>
    
    <bean id = "carBean" class="com.dao.Impl.CarDaoImpl"></bean>

</beans>

applicationContext.xml

package com.serviceImpl;

import com.dao.CarDao;
import com.service.CarService;

public class CarServiceImpl implements CarService {
    private CarDao carDao;
    public CarServiceImpl(CarDao carDao) {
        this.carDao = carDao;
    }
/*    public CarDao getCarDao() {
        return carDao;
    }
    //注入
    public void setCarDao(CarDao carDao) {
        this.carDao = carDao;
    }
*/    
    @Override
    public void add(String args) {
        // 业务操做层
        System.out.println("CarServiceImpl"+args);
        args = args+":"+this.hashCode();
        carDao.append(args);
    }

}

CarServiceImpl