Spring概念

Spring是在2003年兴起的一个轻量级的Java开源框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。他是为了解决企业应用开发的复杂性而开发出来的框架。Spring使用基本的JavaBean来完成以前可能由EJB完成的事情。然而Spring的用途也不仅限于服务器端的开发，从简单性、可测试性和松耦合的角度而言，任何Java应用都会从Spring中收益。

简单来说，Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器框架。

Spring的优点

• 方便解耦，简化开发
  Spring就是一个大工厂，专门负责生成Bean，可以将所有对象创建和依赖关系维护由Spring管理。
• AOP编程的支持
  Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
• 声明式事务的功能
  只需要通过配置就可以完成对事务的管理，而无需手动编程。
• 方便程序的测试
  Spring的Junit4支持，可以通过注解方便的测试Spring程序
• 方便集成其他各种优秀的框架
  Spring不排斥各种其他优秀的开源框架，其内部提供看了对各种优秀框架的支持包括（Struts、Hibernate、MyBaties、Quat2等）
• 降低JavaEE API的使用难度
  对JavaEE开发中一些难用的API（JDBC、JavaMail远程调用WebService等）都提供了封装，使这些API应用难度大大降低。

Spring体系架构

Spring框架是一个分层的框架，它包含一系列的功能要素，并被分为大约20个模块。这些模块分为Core Container、DataAccess/Integration、Web、AOP（Aspect Ocented Programming）Instrumentation和测试部分，如下图所示。

image.png

Spring快速入门

编写流程：

• 下载Spring的jar包 下载链接
• 导入Spring jar包
• 配置Spring的核心xml文件
• 在程序中读取Spring的配置文件来获取Bean【Bean其实是一个new好的对象】

Spring核心jar包详解

spring-core-3.2.2.RELEASE.jar
该jar包包含Spring框架基本的核心工具类，Spring其它组件都要使用到这个包的类，是其他组件的基本核心。

spring-bean-3.2.2RELEASE.jar
该jar包所有应用都会使用到它，它包含访问配置文件，创建和管理bean以及进行Inversion of Control（IOC）/ Dependency Injection（DI）操作相关的所有类。

spring-context-3.2.2.RELEASE.jar
Spring提供在基础的IOC功能上的扩展服务，此外还提供许多企业级服务的支持。如邮件服务、任务调度、JNDI定位、EJB集成，远程访问，缓存以及各种视图层框架的封装等。

spring-expression-3.2.2.RELEASE.jar
Spring 表达式语言。

创建web项目

下载Spring，并导入4个核心jar包（beans、core、context、expression）和一个依赖（common-logging.jar）
注意:导入jar包时，不要导入带sources的源文件。

image.png

Spring IOC控制反转创建实例
创建配置文件beans.xml 配置文件的约束可以访问

image.png

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
......
</beans>

IOC概念

Inverse of control 反转控制的概念，将原本在程序中手动创建的对象的控制权交由Spring框架管理，简单说，就是创建的对象控制权被反转到Spring框架。

DI概念

Dependency Injection 依赖注入，在Spring框架责任创建Bean对象时，动态的将依赖对象注入到Bean组件中。

例子：
在UserService中提供get/set的name方法，在beans.xml中通过property去注入。
UserServiceImpl

public class UserServiceImpl implements UserService {

    private UserDao userDao = new UserDaoImpl();
    private String name;
    private String password;
    private String sex;
    private Integer age;

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

    public void setPassword(String password) {
        this.password = password;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public void register() {
        User user = new User();
        user.setAge(age);
        user.setName(name);
        user.setPassword(password);
        user.setSex(sex);
        userDao.insert(user);
    }
}

Beans.xml

<beans>
    <bean name="userService" class="com.zzx.hibernate.service.impl.UserServiceImpl">
        <property name="name" value="April"/>
        <property name="password" value="123456"/>
        <property name="age" value="27"/>
        <property name="sex" value="女"/>
    </bean>
</beans>

Spring 容器加载的3种方式

• 第一种使用ClassPathXmlApplicationContext

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
UserService userService = (UserService) context.getBean("userService");
userService.register();

• 通过文件系统路径获取配置文件，path参数使用绝对路径

ApplicationContext context = new FileSystemXmlApplicationContext("D:\\IdeaProjects\\hibernate_day05\\src\\beans.xml");
UserService service = (UserService) context.getBean("userService");
service.register();

• 使用BeanFactory，path参数使用绝对路径

BeanFactory factory = new XmlBeanFactory(new FileSystemResource("D:\\IdeaProjects\\hibernate_day05\\src\\beans.xml"));
UserService service = (UserService) factory.getBean("userService");
service.register();

BeanFactory和ApplicationContext比较

BeanFactory采用延迟加载，第一次getBean时才会初始化Bean。
ApplicationContext是对BeanFactory的扩展，提供了更多的功能，包括国际化处理，事件传递、Bean自动装配和各种不同应用层的Context实现。ApplicationContext即时加载。

装配Bean

实例化Bean的三种方式

有些版本可能会失效或报错，原因是因为JDK不兼容导致的，可以降低JDK版本使用1.7或者升级Spring版本到最新的进行测试。

• 使用构造方法实例化
  相当于UserService service = new UserServiceImpl();

<bean id="userServiceId" class="com.zzx.hibernate.service.impl.UserServiceImpl"/>

• 使用静态工厂方法实例化

public class UserServiceFactory {
    public static UserService createUserService() {
        return new UserServiceImpl();
    }
}

<bean id="userService2Id" class="com.zzx.hibernate.service.factory.UserServiceFactory" factory-method="createUserService"/>

• 通过实例工厂方法

<bean id="factoryId" class="com.zzx.hibernate.service.factory.UserServiceFactory"></bean>
<bean id="userService3Id" factory-bean="factoryId" factory-method="createUserService"></bean>

Bean的作用域，掌握前两个即可

image.png

Bean的生命周期

image.png

生命周期图示解读

• instantiate 对象实例化
• populate properties 封装属性
• 如果Bean实现BeanNameAware执行setBeanName()方法
• 如果存在类实现BeanFactoryAware执行setBeanFactory获取Spring容器
• 如果存在类实现BeanPostProcessor（后处理的Bean）执行postProcessBefore Initialization
• 如果Bean实现InitializingBean 执行afterPropertiesSet
• 调用bean init-method=“init”指定初始化方法init
• 如果存在类实现BeanPostProcessor（处理Bean）执行PostProcessAfter Initialization执行业务处理
• 如果Bean实现DisposableBean执行destroy
• 调用bean destroy-method="customerDestroy"指定销毁方法

依赖注入Bean属性

给对象的属性赋值方法

• 构造方法的注入

实体类User构造方法

 public User(String name, String password, String sex, Integer age) {
        this.name = name;
        this.password = password;
        this.sex = sex;
        this.age = age;
    }

bean.xml文件配置

<bean id="user" class="com.zzx.hibernate.domain.User">
    <constructor-arg value="zhangsan"/>
    <constructor-arg value="123456" />
    <constructor-arg value="男" />
    <constructor-arg value="29"/>
</bean>

测试

ApplicationContext context = new ClassPathXmlApplicationContext("beans02.xml");
User user = (User) context.getBean("user");
System.out.println(user);

控制台打印结果：

User{uid=null, name='zhangsan', password='123456', sex='男', age=29}
Process finished with exit code 0

• 构造方法还可以用索引位置来注入，但如果是构造方法重载，可以用type来指定完成

实体类User构造方法

public User(String name,String password,Integer age) {
     this.name = name;
     this.password = password;
     this.age = age;
}

bean.xml文件配置

  <bean id="user1" class="com.zzx.hibernate.domain.User">
    <constructor-arg index="0" value="李四" type="java.lang.String"/>
    <constructor-arg index="1" value="123456" type="java.lang.String"/>
    <constructor-arg index="2" value="28" type="java.lang.Integer"/>
 </bean>

测试

ApplicationContext context = new ClassPathXmlApplicationContext("beans02.xml");
User user = (User) context.getBean("user1");
System.out.println(user);

控制台打印结果

User{uid=null, name='李四', password='null', sex='男', age=29}
Process finished with exit code 0

• 属性setter方法注入

<bean id="user2" class="com.zzx.hibernate.domain.User">
    <property name="name" value="武松"></property>
    <property name="password" value="123456"></property>
    <property name="sex" value="男"></property>
    <property name="age" value="30"></property>
</bean>

• 使用property

  <bean id="user" class="com.zzx.hibernate.domain.User">
        <property name="name" value="April"/>
        <property name="password" value="123456"/>
        <property name="sex" value="女"/>
        <property name="age" value="27"/>
    </bean>

SPEL表达式

<property name="" value="#{表达式}"/>

   <bean id="user" class="com.zzx.hibernate.domain.User">
        <property name="name" value="#{'jack'}"/>
        <property name="age" value="#{'28'}"/>
        <property name="sex" value="#{'男'}"/>
        <property name="password" value="#{'123456'}"/>
    </bean>

集合注入

集合的注入都是给property添加子标签

• 数组

private Integer[] score;
public Integer[] getScore() {
     return score;
}
public void setScore(Integer[] score) {
     this.score = score;
}

beans.xml配置

<property name="score">
     <array>
           <value>88</value>
           <value>90</value>
           <value>99</value>
           <value>98</value>
           <value>97</value>
     </array>
</property>

list 和 set和array使用方法一样，读者可以自己手动写下

• map

private Map<String,String> infos;
public Map<String, String> getInfos() {
      return infos;
}
public void setInfos(Map<String, String> infos) {
    this.infos = infos;
}

beans.xml

 <property name="infos">
      <map>
          <entry key="name" value="April"/>
          <entry key="age" value="27"/>
          <entry key="sex" value="女"/>
     </map>
</property>

• props

private Properties mysqlProperties;
public Properties getMysqlProperties() {
   return mysqlProperties;
}
public void setMysqlProperties(Properties mysqlProperties) {
    this.mysqlProperties = mysqlProperties;
}

beans.xml

<property name="mysqlProperties">
      <props>
           <prop key="name">April</prop>
          <prop key="age">27</prop>
          <prop key="sex">女</prop>
     </props>
</property>

注解取代xml配置文件，注解详解

@Component
它取代了<bean class="">
@Component("id")
取代了<bean id="" class="">
@Web开发提供了@Component 注解衍生注解一样取代<bean class=""
@Repository("名称") dao层
@Service("名称")service层
@Controller("名称") Web层
@AutoWired:自动根据类型注入
@Qualifier("名称")指定自动注入的id名称
@Resource("名称")
@PostConstruct自定义初始化
@PreDestory 自定义销毁
Spring默认情况下注解不生效，开启注解功能

如何开启注解功能呢

beans配置如下

xmlns:context ="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd"

beans.xml

<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd"
>
    <context:annotation-config></context:annotation-config>
    <context:component-scan base-package="com.zzx.hibernate.domain"></context:component-scan>
</beans>

context:component-scan base-package 只要是这个包下的所有文件只要是有注解的都会扫描，初始化注解的对象或实例化对象。
比方说我们在User类的头部添加Component注解，如下

@Component("user")
public class User {
...
}

我们在没有实例化这个对象的情况下使用如下代码就可以实现实例化对象的效果，其实达到的效果和在bean中使用id class指向类的全路径一样的效果。

ApplicationContext context = new ClassPathXmlApplicationContext("beans07.xml");
User user = (User) context.getBean("user");
System.out.println(user);

执行结果，我们可以看出这个对象是不为null的，也就是它实现了对象的实例化操作。

image.png

最后我们结合之前所学习的Struts、Hibernate、Spring完成一个注册的小案例结束本章节。

注册案例

第一步导入Struts、Hibernate以及Spring的jar包。如果有读者不是很了解这些jar包的功能，可以查看我之前写的文章，都有很详细的讲解。
如图所示

image.png

实体类User以及User.hbm.xml文件和hibernate.cfg.xml文件的编写
User类

@Component("user")
public class User {
    private Integer uid;
    private String name;
    private String password;
    private String sex;
    private Integer age;
 public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

User.hbm.xml

<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.zzx.hibernate.domain">
    <class name="User" table="t_user">
        <id name="uid" column="id">
            <generator class="native"></generator>
        </id>
        <property name="name" type="java.lang.String"/>
        <property name="password" type="java.lang.String"/>
        <property name="age" type="java.lang.Integer"/>
        <property name="sex" type="java.lang.String"/>

    </class>
</hibernate-mapping>

hibernate.cfg.xml

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_day03?characterEncoding=UTF-8</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123456</property>
        <property name="hibernate.c3p0.max_size">2</property>
        <property name="hibernate.c3p0.min_size">2</property>
        <property name="hibernate.c3p0.timeout">500</property>
        <property name="hibernate.c3p0.max_statements">100</property>
        <property name="hibernate.c3p0.idle_test_period">3000</property>
        <property name="hibernate.c3p0.acquire_increment">2</property>
        <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
        <property name="hibernate.connection.isolation">4</property>
        <!--是否显示sql语句-->
        <property name="show_sql">true</property>
        <!--是否格式化sql语句-->
        <property name="format_sql">true</property>
        <!--是否自动提交事务-->
        <property name="hibernate.connection.autocommit">true</property>
        <property name="hibernate.current_session_context_class">thread</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
        <property name="hibernate.cache.use_second_level_cache">true</property>

        <property name="hibernate.cache.use_query_cache">true</property>
        <!--配置JavaBean与表的映射文件-->
        <mapping resource="com/zzx/hibernate/domain/Customer.hbm.xml"/>
        <mapping resource="com/zzx/hibernate/domain/Order.hbm.xml"/>
        <mapping resource="com/zzx/hibernate/domain/User.hbm.xml"/>
        <class-cache class="com.zzx.hibernate.domain.Customer" usage="read-only"/>
        <class-cache class="com.zzx.hibernate.domain.Order" usage="read-only"/>

        <!--配置集合缓存-->
        <collection-cache collection="com.zzx.hibernate.domain.Customer.orders" usage="read-only"></collection-cache>
    </session-factory>

</hibernate-configuration>

第二步配置struts以及编写注册的jsp文件
在配置Struts之前，我们需要编写UserAction类

public class UserAction extends ActionSupport implements ModelDriven<User> {

    private User  user = new User();

    private UserService userService;

    public String register() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans07.xml");
        userService = (UserService) context.getBean("userService");
        userService.register(user);
        return SUCCESS;
    }

    @Override
    public User getModel() {
        return user;
    }
}

struts.xml文件配置如下，这个文件放入到src目录下

<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>
    <constant name="struts.devMode" value="true"/>
    <package name="p1" extends="struts-default">
        <action name="user" method="register" class="com.zzx.hibernate.action.UserAction">
            <interceptor-ref name="defaultStack"/>
            <result name="success">/success.jsp</result>
        </action>
    </package>
</struts>

web.xml配置struts拦截器

<filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

register.jsp 文件

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>注册功能</title>
  </head>
  <body>
    <form action="${pageContext.request.contextPath}/user.action" method="post">
      <table>
        <tr>
          <td>
            <label for="name">用户名</label>
          </td>
          <td>
            <input id="name" type="text" placeholder="请输入用户名" name="name">
          </td>
        </tr>

        <tr>
          <td>
            <label for="password">密码</label>
          </td>
          <td>
            <input id="password" type="text" placeholder="请输入密码" name="password">
          </td>
        </tr>

        <tr>
          <td>
            <label for="age">年龄</label>
          </td>
          <td>
            <input id="age" type="number" placeholder="请输入年龄" name="age">
          </td>
        </tr>

        <tr>
          <td>
            <label for="age">性别</label>
          </td>
          <td>
            男<input type="radio" name="sex" id="sex" value="男"> 女 <input name="sex" type="radio" value="女">
          </td>
        </tr>

        <tr>
          <td colspan="2">
            <input type="submit" value="注册">
          </td>
        </tr>
      </table>
    </form>
  </body>
</html>

Service层

@Resource(name = "myUserService")
public class UserServiceImpl implements UserService {
    private UserDao userDao;
    @Override
    public void register(User user) {
        userDao.insert(user);
    }
}

Dao层

@Repository
public class UserDaoImpl implements UserDao {


    @PostConstruct
    public void init_method() {
        System.out.println("自定义初始化方法。。。。。。。。。。");
    }


    @Override
    public void insert(User user) {
        Session session = HibernateUtil.openSession();
        session.save(user);
        System.out.println("保存成功................");
        session.close();
    }

    @Override
    public void update(String name) {

    }

    @PreDestroy
    public void myDestroy() {
        System.out.println("自定义销毁。。。。。。。。。。。。");
    }
}

接下来配置Spring的beans文件

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd"
>

    <context:annotation-config></context:annotation-config>
    <context:component-scan base-package="com.zzx.hibernate"></context:component-scan>

    <bean id="userDao" class="com.zzx.hibernate.dao.impl.UserDaoImpl"/>
    <bean id="userService" class="com.zzx.hibernate.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>
</beans>

这样我们的案例的所有代码都编写完了，接下来我们再来执行下代码看下效果。
代码运行起来后，会在浏览器中出现如下界面

image.png

然后点击提交，在控制台会输入如下日志

image.png

image.png