Spring框架详解(Spring基础配置和开发步骤)

小灰灰 2021-03-16 15:39 504阅读 0赞

Spring是一个非常活跃的开源框架, 它是一个基于IOC和AOP来构架多层JavaEE系统的框架,它的主要目地是简化企业开发

Spring以一种非侵入式的方式来管理你的代码, Spring提倡”最少侵入”，这也就意味着你可以适当的时候安装或卸载Spring

Spring框架的主页：http://www.springsource.org/ Spring

框架下载地址：http://www.springsource.org/download

在项目中引入spring立即可以带来下面的好处

降低组件之间的耦合度,实现软件各层之间的解耦。

IOC(依赖注入)：包含并管理应用对象的配置和生命周期，你可以配置你的每个bean如何被创建，也可以配置每个bean是只有一个实例，还是每次需要时都生成一个新的实例，以及它们是如何相互关联的

\*谓依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到另一个对象中。

AOP(面向切面)：采用了面向切面编程来实现很多基础但是与业务逻辑无关的功能的解耦,比如：事务管理、日志、权限验证.....

DAO:Spring 还提供了对数据库JDBC的封装,使用JdbcTemplate来简化数据操作

ORM：提供了对主流的对象关系映射框架的支持

JEE: 对Java企业级开发提供了一些解决方案,例如EJB、JMS等

WEB: 提供了自己的Spring MVC和对显示层框架的集合支持

实例化Spring容器常用的两种方式：

方法一: 在类路径下寻找配置文件来实例化容器 ApplicationContext ctx = new ClassPathXmlApplicationContext(new String\[\]\{"beans.xml"\}); 可以在整个类路径中寻找xml文件 \* 通过这种方式加载。需要将spring的配置文件放到当前项目的classpath路径下 \* classpath路径指的是当前项目的src目录，该目录是java源文件的存放位置。

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

Spring初始化bean或销毁bean时，有时需要作一些处理工作，因此spring可以在创建和销毁bean的时候调用bean的两个生命周期方法。
````
<bean id=“foo” class=“...Foo” init-method=“setup” destory-method=“teardown”/>
````
\----当bean被载入到容器的时候调用setup

\----当bean从容器中删除的时候调用teardown(scope= singleton有效)

singleton(默认值) 在每个Spring IoC容器中一个bean定义只有一个对象实例(共享)。

默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。

如： <bean id="xxx" class="cn.itcast.OrderServiceBean" lazy-init="true"/> .

prototype 允许bean可以被多次实例化(使用一次就创建一个实例)

注入依赖对象可以采用手工装配或自动装配，在实际应用中建议使用手工装配，因为自动装配会产生未知情况,开发人员无法预见最终的装配结果。

````
// 1. 实体类

class User{

}

//2. dao

class  UserDao{
  .. 访问db

}

//3. service

class  UserService{
   UserDao userDao = new UserDao();

}

//4. action

class  UserAction{
   UserService userService = new UserService();  ..
   拿到数据或结果

}
````

用户访问：

/user.action ---->  Tomcat  (服务器创建Action、Service、dao

思考：
   1. 对象创建创建能否写死？
   2. 对象创建细节
       对象数量
           action  多个   【维护成员变量】
           service 一个   【不需要维护公共变量】
           dao     一个   【不需要维护公共变量】
       创建时间
           action    访问时候创建
           service   启动时候创建
           dao       启动时候创建
   3. 对象的依赖关系
       action 依赖 service
       service依赖 dao

=======================================================

总结：
   spring就是解决上面的问题的！

简单来说，就是处理对象的创建的、以及对象的依赖关系！

#2. Spring框架#

##专业术语了解##

**组件/框架设计**

侵入式设计

引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。

例如： Struts框架

非侵入式设计

引入了框架，对现有的类结构没有影响。

例如：Hibernate框架 / Spring框架

**控制反转:**

Inversion on Control , 控制反转 IOC

对象的创建交给外部容器完成，这个就做控制反转.

依赖注入，  dependency injection

处理对象的依赖关系

区别：

控制反转， 解决对象创建的问题 【对象创建交给别人】

依赖注入，

在创建完对象后， 对象的关系的处理就是依赖注入 【通过set方法依赖注入】

**AOP**

面向切面编程。切面，简单来说来可以理解为一个类，由很多重复代码形成的类。

切面举例：事务、日志、权限;

## Spring框架##

###a. 概述###

Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。

且可以和其他框架一起使用；Spring与Struts,  Spring与hibernate

(起到整合（粘合）作用的一个框架)

Spring提供了一站式解决方案：

1） Spring Core  spring的核心功能： IOC容器, 解决对象创建及依赖关系

2） Spring Web  Spring对web模块的支持。

\-à 可以与struts整合,让struts的action创建交给spring

-à spring mvc模式

3） Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】

4） Spring ORM  spring对orm的支持：

à 既可以与hibernate整合，【session】

à 也可以使用spring的对hibernate操作的封装

5）Spring AOP  切面编程

6）SpringEE   spring 对javaEE其他模块的支持

###b. 开发步骤###

spring各个版本中：

在3.0以下的版本，源码有spring中相关的所有包【spring功能 \+ 依赖包】

如2.5版本；

在3.0以上的版本，源码中只有spring的核心功能包【没有依赖包】

(如果要用依赖包，需要单独下载！)

1） 源码, jar文件：spring-framework-3.2.5.RELEASE

commons-logging-1.1.3.jar           日志

spring-beans-3.2.5.RELEASE.jar        bean节点

spring-context-3.2.5.RELEASE.jar       spring上下文节点

spring-core-3.2.5.RELEASE.jar         spring核心功能

spring-expression-3.2.5.RELEASE.jar    spring表达式相关表

以上是必须引入的5个jar文件，在项目中可以用户库管理！

2） 核心配置文件: applicationContext.xml

Spring配置文件：applicationContext.xml / bean.xml

约束参考：

spring-framework-3.2.5.RELEASE\\docs\\spring-framework-reference\\htmlsingle\\index.html
````
<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"
   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">

</beans>   
````

**3）Api**
````
public class App {
 
// 1. 通过工厂类得到IOC容器创建的对象
@Test
public void testIOC() throws Exception {
// 创建对象
// User user = new User();
 
// 现在，把对象的创建交给spring的IOC容器
Resource resource = new ClassPathResource("cn/itcast/a_hello/applicationContext.xml");
// 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
BeanFactory factory = new XmlBeanFactory(resource);
// 得到容器创建的对象
User user = (User) factory.getBean("user");
 
System.out.println(user.getId());
 
}
 
//2. （方便）直接得到IOC容器对象

@Test
public void testAc() throws Exception {
// 得到IOC容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
// 从容器中获取bean
User user = (User) ac.getBean("user");
 
System.out.println(user);
}
}
````

## bean对象创建的细节##

````
/*
  1) 对象创建： 单例/多例
 * scope="singleton", 默认值， 即 默认是单例 【service/dao/工具类】
 *  scope="prototype", 多例； 【Action对象】
 
  2) 什么时候创建?
 *   scope="prototype"  在用到对象的时候，才创建对象。
 *    scope="singleton"  在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
 * 3)是否延迟创建
 *   lazy-init="false"  默认为false,  不延迟创建，即在启动时候就创建对象
 *   lazy-init="true"   延迟初始化， 在用到对象的时候才创建对象
 *    （只对单例有效）
 * 4) 创建对象之后，初始化/销毁
 *   init-method="init_user"       【对应对象的init_user方法，在对象创建爱之后执行 】
 *    destroy-method="destroy_user"  【在调用容器对象的destriy方法时候执行，(容器用实现类)】
 */
@Test
public void testIOC() throws Exception {
// 得到IOC容器对象  【用实现类，因为要调用销毁的方法】
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
System.out.println("-----容器创建-----");
 
// 从容器中获取bean
User user1 = (User) ac.getBean("user");
User user2 = (User) ac.getBean("user");
 
System.out.println(user1);
System.out.println(user2);
 
// 销毁容器对象
ac.destroy();
}
````

##SpringIOC容器##

###1） 创建对象###

SpringIOC容器，是spring核心内容。

作用： 创建对象 & 处理对象的依赖关系

IOC容器创建对象：

创建对象, 有几种方式：

1） 调用无参数构造器

2） 带参数构造器

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

 

 

<bean id="user2" class="cn.itcast.b_create_obj.User">
<constructor-arg index="0" type="int" value="100"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
</bean>
 

<bean id="str" class="java.lang.String">
<constructor-arg value="Jacks"></constructor-arg>
</bean>
<bean id="user3" class="cn.itcast.b_create_obj.User">
<constructor-arg index="0" type="int" value="100"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
</bean>
 
 



<bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>

<bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
 
 


<bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
 
</beans>      
````

###2） 对象依赖关系###

Spring中，如何给对象的属性赋值?  【DI, 依赖注入】

1) 通过构造函数

2) 通过set方法给属性注入值

3) p名称空间

4)自动装配(了解)

5) 注解

####\#  (常用)****S****et方法注入值####

````

<bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
 

<bean id="userService" class="cn.itcast.c_property.UserService">
<property name="userDao" ref="userDao"></property>
</bean>
 

<bean id="userAction" class="cn.itcast.c_property.UserAction">
<property name="userService" ref="userService"></property>
</bean>
````

####\# 内部bean####

````

<bean id="userAction" class="cn.itcast.c_property.UserAction">
<property name="userService">
<bean class="cn.itcast.c_property.UserService">
<property name="userDao">
<bean class="cn.itcast.c_property.UserDao"></bean>
</property>
</bean>
</property>
</bean>
````

####\# p 名称空间注入属性值 (优化)####

####\# 自动装配(了解)####

ü **根据名称自动装配：****autowire="byName"**

**-****à**** 自动去IOC容器中找与属性名同名的引用的对象，并自动注入**

````
  
<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>
<bean id="userService" class="cn.itcast.d_auto.UserService" autowire="byName"></bean>

<bean id="userAction" 
class="cn.itcast.d_auto.UserAction" autowire="byName"></bean>
````

**也可以定义到全局， 这样就不用每个bean节点都去写autowire=****”****byName****”**

ü **根据类型自动装配：****autowire="****byType****"**

**必须确保改类型在IOC容器中只有一个对象；否则报错。**
````
<?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"
    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" default-autowire="byType">
 
  
<bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>
<bean id="userService" class="cn.itcast.d_auto.UserService"></bean>
 

<bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>
 
 

</beans>  
````

**总结：**

**S****pring提供的自动装配主要是为了简化配置； 但是不利于后期的维护。**

**(一般不推荐使用)**

####\# 注解####

注解方式可以简化spring的IOC容器的配置!

使用注解步骤：

1）先引入context名称空间
````
xmlns:context="http://www.springframework.org/schema/context"
````
2）开启注解扫描
````
<context:component-scan base-package="cn.itcast.e_anno2"></context:component-scan>
````
3）使用注解

通过注解的方式，把对象加入ioc容器。

创建对象以及处理对象依赖关系，相关的注解：

@Component   指定把一个对象加入IOC容器

@Repository   作用同@Component； 在持久层使用

@Service      作用同@Component； 在业务逻辑层使用

@Controller    作用同@Component； 在控制层使用

@Resource     属性注入

总结：

1） 使用注解，可以简化配置，且可以把对象加入IOC容器,及处理依赖关系(DI)  
2） 注解可以和XML配置一起使用。