Spring的基本使用

Spring概述

一、什么是Spring

• Spring是一个开放源代码的设计层面框架，
• 他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。
• Spring是于2003 年兴起的一个轻量级的Java 开发框架
• 简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。

二、Spring特点

1.方便解耦，简化开发

通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2.AOP编程的支持

通过Spring提供的AOP功能，方便进行面向切面的编程，，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

3.声明式事务的支持

在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

4.方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。

5.方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。

6.降低Java EE API的使用难度

Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）

提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

7.Java 源码是经典学习范例

Spring的源码设计精妙、结构清晰、匠心独运，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

三、下载

下载地址

IOC

一、什么IOC

IOC：Inversion of Control（控制反转）

控制反转：将对象的创建权反转给（交给）Spring。

二、传统开发模式

传统开发模式 业务和实现类过于紧密，底层业务要修改源代码

通过工厂可以实现，接口与实现业务的分离

在工厂内部使用配置文件加载

三、使用spring-IOC

1.添加jar包

2.创建配置文件

通常名称起为 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">
</beans>

编写接口和实现类

public interface UserDao {
    public void save();
    public void delete();
}


public class UserDaoMysqlImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("mysql-save");
    }

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


public class UserDaoOracleImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("oracle-save");
    }

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

3.添加配置文件

<?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">

<!-- id: 为自己起的名称； class：为接口实现类的全路径 -->
<bean id="userDao" class="com.xzh.demo1.UserDaoMysqlImpl"/>
</beans>

4.测试使用

public class UserTest {

    @Test
    public void test(){

        // 1.加载配置文件
        ApplicationContext applicationContext =
        new ClassPathXmlApplicationContext("applicationContext.xml");

        // 2.根据id获取对象
        UserDao userDao = (UserDao)applicationContext.getBean("userDao");
        userDao.save();
        userDao.delete();
    }
	
}

四、DI 依赖注入

依赖注入

• 前提必须有IOC的环境
• Spring管理这个类的时候才能将类的依赖的属性值注入（设置）进来
• 依赖注入：给spring管理类当中依赖的属性，通过配置文件进行赋值的过程

传统方式

UserDaoOracleImpl.java 新增属性 name

public class UserDaoOracleImpl implements UserDao {

    public String name;

    @Override
    public void save() {
        System.out.println("oracle-save");
    }

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

传统方式：

@Test
public void test2(){
	UserDaoOracleImpl userDaoOracle = new UserDaoOracleImpl();
	userDaoOracle.name = "IT";
	System.out.println(userDaoOracle.name);
} 

DI方式

1.实现类当中的属性要提供set方法

public class UserDaoOracleImpl implements UserDao {

    public String name;

    // 依赖注入需要提供set方法
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public void save() {
        System.out.println("oracle-save");
    }

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

2.在配置文件当中配置依赖注入

<!-- id: 为自己起的名称； class：为接口实现类的全路径 -->
<bean id="userDao" class="com.xzh.demo1.UserDaoOracleImpl">
	<property name="name" value="IT666"/>
</bean>

测试

@Test
public void test2() {
	// 1.加载配置文件
	ApplicationContext applicationContext = 
		new ClassPathXmlApplicationContext("applicationContext.xml");
	UserDaoOracleImpl obj = (UserDaoOracleImpl) applicationContext.getBean("userDao");
	System.out.println(obj.name);
}

五、Spring的工厂类

BeanFactory

• 老版本使用方式
• 当调用getBean的时候才会创建实例对象

ApplicationContext

• 新版本使用方式
• 当加载配置文件时候就会创建实例对象

ApplicationContext实现类

1. ClassPathXmlApplicationContext
   加载类路径下的配置文件

2. FileSystemXmlApplicationContext
   加载文件系统下的配置文件

Bean相关配置

一、名称与标识

1. id

使用了约束中的唯一约束。里面不能出现特殊字符的

2. name

没有使用约束中的唯一约束。里面可以出现特殊字符。

二、设置对象的生命周期方法

1. init-method

Bean被初始化的时候执行的方法

2. destroy-method

Bean被销毁的时候执行的方法（Bean是单例创建，工厂关闭）

示例

Person 类

public class Person {
    public String name;

    public void setName(String name) {
        this.name = name;
    }

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

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

applicationContext.xml 文件中增加配置

<!-- init-method:对象创建时,指定调用的方法；destroy-method:对象销毁时,指定调用的方法 -->
<bean id="person" class="com.xzh.demo2.Person" init-method="init"
	destroy-method="destroy">
	<property name="name" value="IT888" />
</bean>

编写测试类

@Test
public void test() {
	// 加载 核心配置文件 会帮你创建对象 所有的对象
	ClassPathXmlApplicationContext applicationContext = 
		new ClassPathXmlApplicationContext("applicationContext.xml");

	Person person1 = (Person) applicationContext.getBean("person");
	Person person2 = (Person) applicationContext.getBean("person");
	System.out.println(person1);  // 单例，每次获取的地址都相同
	System.out.println(person2);
	System.out.println(person1.name);
	// 使用单例:关闭工厂 (所有的对象都 会销毁)
	applicationContext.close();
}

测试结果

init
com.xzh.demo2.Person@8e24743
com.xzh.demo2.Person@8e24743
IT888
destroy

三、Bean的作用范围的配置

scope

1. singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂 ，所有的对象都会销毁。
2. prototype：多例模式。关闭工厂 ，所有的对象不会销毁。内部的垃圾回收机制会回收。
3. request： 应用在web项目中，Spring创建这个类以后，将这个对象存入到request范围中。
4. session：应用在web项目中，Spring创建这个类以后，将这个对象存入到session范围中
5. globalsession：应用在web项目中，必须在porlet(基于Java的Web组件，子域名)环境下使用。但是如果没有这种环境，相对于session。

四、工厂实例化的方式

1. 无参构造-默认

public class User {
	public User() {
		super();
		System.out.println("默认构造方法");
	}
}

applicationContext.xml 配置：

<bean id="user" class="com.xzh.demo3.User"></bean>

测试类：

@Test
public void test(){
   ApplicationContext applicationContext = new
			ClassPathXmlApplicationContext("applicationContext.xml");
	User user = (User)applicationContext.getBean("user");
	System.out.println(user);
}

2. 静态工厂实例化

public class User {
	public static User createUser() {
		System.out.println("调用了createUser----");
		return new User();
	}
}

applicationContext.xml 配置：

<bean id="user" class="com.xzh.demo3.User" factory-method="createUser"></bean>

测试类：

@Test
public void test(){
   ApplicationContext applicationContext = new
			ClassPathXmlApplicationContext("applicationContext.xml");
	User user = (User)applicationContext.getBean("user");
	System.out.println(user);
}

3. 实例工厂实例化

public class User {
	public static User createUser() {
		System.out.println("调用了createUser----");
		return new User();
	}
}

applicationContext.xml 配置：

<bean id="user" class="com.xzh.demo3.User" factory-method="createUser"></bean>
<bean id="user2" class="com.xzh.demo3.User" factory-bean="user"></bean>

测试类：

@Test
public void test(){
   ApplicationContext applicationContext = new
			ClassPathXmlApplicationContext("applicationContext.xml");
	User user = (User)applicationContext.getBean("user2");
	System.out.println(user);
}

分模块配置

1. 在加载时，添加多个配置文件名称

2. 在一个配置文件当中引入另一个配置文件