Mybatis【与Spring整合】

导入jar包

以下使用的是Oracle数据库来进行测试

  • aopalliance.jar
  • asm-3.3.1.jar
  • aspectjweaver.jar
  • c3p0-0.9.1.2.jar
  • cglib-2.2.2.jar
  • commons-logging.jar
  • log4j-1.2.16.jar
  • mybatis-3.1.1.jar
  • mybatis-spring-1.1.1.jar
  • mysql-connector-java-5.1.7-bin.jar
  • ojdbc5.jar
  • org.springframework.aop-3.0.5.RELEASE.jar
  • org.springframework.asm-3.0.5.RELEASE.jar
  • org.springframework.beans-3.0.5.RELEASE.jar
  • org.springframework.context-3.0.5.RELEASE.jar
  • org.springframework.core-3.0.5.RELEASE.jar
  • org.springframework.expression-3.0.5.RELEASE.jar
  • org.springframework.jdbc-3.0.5.RELEASE.jar
  • org.springframework.orm-3.0.5.RELEASE.jar
  • org.springframework.transaction-3.0.5.RELEASE.jar
  • org.springframework.web.servlet-3.0.5.RELEASE.jar
  • org.springframework.web-3.0.5.RELEASE.jar

创建表

create table emps(
eid number(5) primary key,
ename varchar2(20),
esal number(8,2),
esex varchar2(2)
);

创建实体

package entity;

/**
 * 员工
 * @author AdminTC
 */
public class Emp {
    private Integer id;
    private String name;
    private Double sal;
    private String sex;
    public Emp(){}
    public Emp(Integer id, String name, Double sal, String sex) {
        this.id = id;
        this.name = name;
        this.sal = sal;
        this.sex = sex;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getSal() {
        return sal;
    }
    public void setSal(Double sal) {
        this.sal = sal;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}

创建实体与表的映射文件

<?xml version=”1.0” encoding=”UTF-8” ?>
<!DOCTYPE mapper PUBLIC “-//mybatis.org//DTD Mapper 3.0//EN”
http://mybatis.org/dtd/mybatis-3-mapper.dtd">












insert into emps(eid,ename,esal,esex) values(#{id},#{name},#{sal},#{sex})


创建Mybatis映射文件配置环境

数据库的信息交由Spring管理!Mybatis配置文件负责加载对应映射文件即可

<configuration>
    <mappers>
        <mapper resource="zhongfucheng/entity/EmpMapper.xml"/>

    </mappers>
</configuration>

配置Spring核心过滤器【也是加载总配置文件】

<!-- 核心springmvc核心控制器 -->
<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>*.action</url-pattern>
</servlet-mapping>

配置数据库信息、事务

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


    <!-- 配置C3P0连接池,目的:管理数据库连接 -->
    <bean id="comboPooledDataSourceID" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="oracle.jdbc.driver.OracleDriver"/>
        <property name="jdbcUrl" value="jdbc:oracle:thin:@127.0.0.1:1521:test"/>
        <property name="user" value="scott"/>
        <property name="password" value="tiger"/>
    </bean>


    <!-- 配置SqlSessionFactoryBean,目的:加载mybaits配置文件和映射文件,即替代原Mybatis工具类的作用 -->
    <bean id="sqlSessionFactoryBeanID" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="configLocation" value="classpath:mybatis.xml"/>
        <property name="dataSource" ref="comboPooledDataSourceID"/>
    </bean>


    <!-- 配置Mybatis的事务管理器,即因为Mybatis底层用的是JDBC事务管事器,所以在这里依然配置JDBC事务管理器 -->
    <bean id="dataSourceTransactionManagerID" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="comboPooledDataSourceID"/>
    </bean>

    <!-- 配置事务通知,即让哪些方法需要事务支持 -->
    <tx:advice id="tx" transaction-manager="dataSourceTransactionManagerID">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!-- 配置事务切面,即让哪些包下的类需要事务 -->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* cn.com.service.*.*(..))"/>
        <aop:advisor advice-ref="tx" pointcut-ref="pointcut"/>
    </aop:config>

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


</beans>

创建Dao、Service、Action

@Repository
public class EmpDao {
    @Autowired
    private SqlSessionFactory sqlSessionFactory;
    /**
     * 增加员工
     */
    public void add(Emp emp) throws Exception {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        sqlSession.insert("empNamespace.add", emp);
        sqlSession.close();
    }


}

@Service
public class EmpService {


    @Autowired
    private zhongfucheng.dao.EmpDao empDao;
    public void addEmp(Emp emp) throws Exception {
        empDao.add(emp);
    }
}

@Controller
@RequestMapping("/emp")
public class EmpAction {

    @Autowired
    private EmpService empService;

    @RequestMapping("/register")
    public void register(Emp emp) throws Exception {
        empService.addEmp(emp);
        System.out.println("注册成功");
    }

}

JSP页面测试

<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>员工注册</title>
  </head>
  <body>
    <form action="${pageContext.request.contextPath}/emp/register.action" method="POST">
        <table border="2" align="center">
            <tr>
                <th>编号</th>
                <td><input type="text" name="id"></td>
            </tr>
            <tr>
                <th>姓名</th>
                <td><input type="text" name="name"></td>
            </tr>
            <tr>
                <th>薪水</th>
                <td><input type="text" name="sal"></td>
            </tr>
            <tr>
                <th>性别</th>
                <td>
                    <input type="radio" name="sex" value="男"/>男
                    <input type="radio" name="sex" value="女" checked/>女
                </td>
            </tr>
            <tr>
                <td colspan="2" align="center">
                    <input type="submit" value="注册"/>
                </td>
            </tr>
        </table>
    </form>     
  </body>
</html>

总结

  • web.xml加载Spring配置文件
  • Spring配置文件配置数据连接池,SessionFactory、事务、扫描注解
  • Mybatis总配置文件、实体以及相对应的映射文件
  • 将映射文件加入到总配置文件中

mybatis【入门】

什么是MyBatis

Spring是一个开源框架,它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis。是一个基于Java的持久层框架

为什么我们要用Mybatis?

无论是Mybatis、Hibernate都是ORM的一种实现框架,都是对JDBC的一种封装!

我们已经在持久层中学了几种技术了…

  • Hibernate
  • jdbc
  • SpringDAO

那我们为啥还要学Mybatis呢???现在Mybatis在业内大行其道,那为啥他能那么火呢??

Hibernate是一个比较老旧的框架,用过他的同学都知道,只要你会用,用起来十分舒服…啥sql代码都不用写…但是呢,它也是有的缺点::处理复杂业务时,灵活度差, 复杂的HQL难写难理解,例如多表查询的HQL语句

而JDBC很容易理解,就那么几个固定的步骤,就是开发起来太麻烦了,因为什么都要我们自己干

而SpringDAO其实就是JDBC的一层封装,就类似于dbutils一样,没有特别出彩的地方

我们可以认为,Mybatis就是jdbc和Hibernate之间的一个平衡点…毕竟现在业界都是用这个框架,我们也不能不学呀!

Mybatis快速入门

我们已经学过了Hibernate了,对于Mybatis入门其实就非常类似的,因此就很简单就能掌握基本的开发了。

导入开发包

导入Mybatis开发包

  • mybatis-3.1.1.jar
  • commons-logging-1.1.1.jar
  • log4j-1.2.16.jar
  • cglib-2.2.2.jar
  • asm-3.3.1.jar

导入mysql/oracle开发包

  • mysql-connector-java-5.1.7-bin.jar
  • Oracle 11g 11.2.0.1.0 JDBC_ojdbc6.jar

准备测试工作

创建一张表:

create table students(
  id  int(5) primary key,
  name varchar(10),
  sal double(8,2)
);

创建实体:

/**
 * Created by xing on 2017/7/21.
 */

public class Student {
    private Integer id;
    private String name;
    private Double sal;

    public Student() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Double getSal() {
        return sal;
    }

    public void setSal(Double sal) {
        this.sal = sal;
    }
}

创建mybatis配置文件

创建mybatis的配置文件,配置数据库的信息,数据库我们可以配置多个,但是默认的只能用一个.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>


    <!-- 加载类路径下的属性文件 -->
    <properties resource="db.properties"/>

    <!-- 设置一个默认的连接环境信息 -->
    <environments default="mysql_developer">
        <!-- 连接环境信息,取一个任意唯一的名字 -->
        <environment id="mysql_developer">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="jdbc"/>
            <!-- mybatis使用连接池方式来获取连接 -->
            <dataSource type="pooled">
                <!-- 配置与数据库交互的4个必要属性 -->
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>
            </dataSource>
        </environment>


        <!-- 连接环境信息,取一个任意唯一的名字 -->
        <environment id="oracle_developer">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="jdbc"/>
            <!-- mybatis使用连接池方式来获取连接 -->
            <dataSource type="pooled">
                <!-- 配置与数据库交互的4个必要属性 -->
                <property name="driver" value="${oracle.driver}"/>
                <property name="url" value="${oracle.url}"/>
                <property name="username" value="${oracle.username}"/>
                <property name="password" value="${oracle.password}"/>
            </dataSource>
        </environment>
    </environments>


</configuration>

编写工具类测试是否获取到连接

使用Mybatis的API来创建一个工具类,通过mybatis配置文件与数据库的信息,得到Connection对象

package cn.javaee.mybatis.util;

import java.io.IOException;
import java.io.Reader;
import java.sql.Connection;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

/**
 * 工具类
 * @author xing
 */
public class MybatisUtil {
    private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();
    private static SqlSessionFactory sqlSessionFactory;
    /**
     * 加载位于src/mybatis.xml配置文件
     */
    static{
        try {
            Reader reader = Resources.getResourceAsReader("mybatis.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    /**
     * 禁止外界通过new方法创建 
     */
    private MybatisUtil(){}
    /**
     * 获取SqlSession
     */
    public static SqlSession getSqlSession(){
        //从当前线程中获取SqlSession对象
        SqlSession sqlSession = threadLocal.get();
        //如果SqlSession对象为空
        if(sqlSession == null){
            //在SqlSessionFactory非空的情况下,获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession();
            //将SqlSession对象与当前线程绑定在一起
            threadLocal.set(sqlSession);
        }
        //返回SqlSession对象
        return sqlSession;
    }
    /**
     * 关闭SqlSession与当前线程分开
     */
    public static void closeSqlSession(){
        //从当前线程中获取SqlSession对象
        SqlSession sqlSession = threadLocal.get();
        //如果SqlSession对象非空
        if(sqlSession != null){
            //关闭SqlSession对象
            sqlSession.close();
            //分开当前线程与SqlSession对象的关系,目的是让GC尽早回收
            threadLocal.remove();
        }
    }   
    /**
     * 测试
     */
    public static void main(String[] args) {
        Connection conn = MybatisUtil.getSqlSession().getConnection();
        System.out.println(conn!=null?"连接成功":"连接失败");
    }
}

创建实体与映射关系文件

配置实体与表的映射关系

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- namespace属性是名称空间,必须唯一 -->
<mapper namespace="cn.com.Student">    

    <!-- resultMap标签:映射实体与表 
         type属性:表示实体全路径名
         id属性:为实体与表的映射取一个任意的唯一的名字
    -->
    <resultMap type="student" id="studentMap">
        <!-- id标签:映射主键属性
             result标签:映射非主键属性
             property属性:实体的属性名
             column属性:表的字段名  
        -->                         
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="sal" column="sal"/>
    </resultMap>

</mapper>

现在我们已经有了Mybatis的配置文件和表与实体之前的映射文件了,因此我们要将配置文件和映射文件关联起来

<mappers>
    <mapper resource="StudentMapper.xml"/>
</mappers>

编写DAO

public class StudentDao {


    public void add(Student student) throws Exception {
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        sqlSession.insert();
    }

    public static void main(String[] args) throws Exception {

        StudentDao studentDao = new StudentDao();

        Student student = new Student(1, "zhongfucheng", 10000D);
        studentDao.add(student);

    }
}

到现在为止,我们实体与表的映射文件仅仅映射了实体属性与表的字段的关系,而我们Mybatis是需要自己手动编写SQL代码,在实体与表的映射文件中写。

==Mybatis实体与表的映射文件中提供了insert标签==【SQL代码片段】供我们使用

//在JDBC中我们通常使用?号作为占位符,而在Mybatis中,我们是使用#{}作为占位符
//parameterType我们指定了传入参数的类型
//#{}实际上就是调用了Student属性的get方法

<insert id="add" parameterType="Student">

    INSERT INTO ZHONGFUCHENG.STUDENTS (ID, NAME, SAL) VALUES (#{id},#{name},#{sal});
</insert>

在程序中调用映射文件的SQL代码片段

public void add(Student student) throws Exception {
    //得到连接对象
    SqlSession sqlSession = MybatisUtil.getSqlSession();
    try{
        //映射文件的命名空间.SQL片段的ID,就可以调用对应的映射文件中的SQL
        sqlSession.insert("StudentID.add", student);
        sqlSession.commit();
    }catch(Exception e){
        e.printStackTrace();
        sqlSession.rollback();
        throw e;
    }finally{
        MybatisUtil.closeSqlSession();
    }
}

值得注意的是:Mybatis中的事务是默认开启的,因此我们在完成操作以后,需要我们手动去提交事务!

Mybatis工作流程

  • 通过Reader对象读取Mybatis映射文件
  • 通过SqlSessionFactoryBuilder对象创建SqlSessionFactory对象
  • 获取当前线程的SQLSession
  • 事务默认开启
  • 通过SQLSession读取映射文件中的操作编号,从而读取SQL语句
  • 提交事务
  • 关闭资源

Mybatis分页

分页是一个非常实用的技术点,我们也来学习一下使用Mybatis是怎么分页的!

我们的分页是需要多个参数的,并不是像我们之前的例子中只有一个参数。当需要接收多个参数的时候,我们使用Map集合来装载!

public List<Student>  pagination(int start ,int end) throws Exception {
    //得到连接对象
    SqlSession sqlSession = MybatisUtil.getSqlSession();
    try{
        //映射文件的命名空间.SQL片段的ID,就可以调用对应的映射文件中的SQL


        /**
         * 由于我们的参数超过了两个,而方法中只有一个Object参数收集
         * 因此我们使用Map集合来装载我们的参数
         */
        Map<String, Object> map = new HashMap();
        map.put("start", start);
        map.put("end", end);
        return sqlSession.selectList("StudentID.pagination", map);
    }catch(Exception e){
        e.printStackTrace();
        sqlSession.rollback();
        throw e;
    }finally{
        MybatisUtil.closeSqlSession();
    }
}
public static void main(String[] args) throws Exception {
    StudentDao studentDao = new StudentDao();
    List<Student> students = studentDao.pagination(0, 3);
    for (Student student : students) {

        System.out.println(student.getId());

    }

}

那么在实体与表映射文件中,我们接收的参数就是map集合

<!--分页查询-->
<select id="pagination" parameterType="map" resultMap="studentMap">

    /*根据key自动找到对应Map集合的value*/
    select * from students limit #{start},#{end};

</select>

Mapper代理方式

Mapper代理方式的意思就是:程序员只需要写dao接口,dao接口实现对象由mybatis自动生成代理对象。

我们可以发现DaoImpl是十分重复的:

  • dao的实现类中存在重复代码,整个mybatis操作的过程代码模板重复(先创建sqlsession、调用sqlsession的方法、关闭sqlsession)
  • dao的实现 类中存在硬编码,调用sqlsession方法时将statement的id硬编码。

以前的重复代码和硬编码如下:

public class StudentDao {

    public void add(Student student) throws Exception {
        //得到连接对象
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        try{
            //映射文件的命名空间.SQL片段的ID,就可以调用对应的映射文件中的SQL
            sqlSession.insert("StudentID.add", student);
            sqlSession.commit();
        }catch(Exception e){
            e.printStackTrace();
            sqlSession.rollback();
            throw e;
        }finally{
            MybatisUtil.closeSqlSession();
        }
    }
    public static void main(String[] args) throws Exception {
        StudentDao studentDao = new StudentDao();
        Student student = new Student(3, "zhong3", 10000D);
        studentDao.add(student);
    }
}

Mapper开发规范

想要Mybatis帮我们自动生成Mapper代理的话,我们需要遵循以下的规范:

  • mapper.xml中namespace指定为mapper接口的全限定名
    • 此步骤目的:通过mapper.xml和mapper.java进行关联
  • mapper.xml中statement的id就是mapper.java中方法名
  • mapper.xml中statement的parameterType和mapper.java中方法输入参数类型一致
  • mapper.xml中statement的resultType和mapper.java中方法返回值类型一致

==再次说明:statement就是我们在mapper.xml文件中命名空间+sql指定的id==

Mapper代理返回值问题

mapper接口方法返回值:

  • 如果是返回的单个对象,返回值类型是pojo类型,生成的代理对象内部通过selectOne获取记录
  • 如果返回值类型是集合对象,生成的代理对象内部通过selectList获取记录

Mybatis解决JDBC编程的问题

  • 数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能,如果使用数据库链接池可解决此问题。
    • 解决:在SqlMapConfig.xml中配置数据链接池,使用连接池管理数据库链接。
  • Sql语句写在代码中造成代码不易维护,实际应用sql变化的可能较大,sql变动需要改变java代码。
    • 解决:将Sql语句配置在XXXXmapper.xml文件中与java代码分离。
  • 向sql语句传参数麻烦,因为sql语句的where条件不一定,可能多也可能少,占位符需要和参数一一对应。
    • 解决:Mybatis自动将java对象映射至sql语句,通过statement中的parameterType定义输入参数的类型。
  • 对结果集解析麻烦,sql变化导致解析代码变化,且解析前需要遍历,如果能将数据库记录封装成pojo对象解析比较方便。
    • 解决:Mybatis自动将sql执行结果映射至java对象,通过statement中的resultType定义输出结果的类型。

总结

  • Mybatis的准备工作与Hibernate差不多,都需要一个总配置文件、一个映射文件。
  • Mybatis的SQLSession工具类使用ThreadLocal来对线程中的Session来进行管理。
  • Mybatis的事务默认是开启的,需要我们手动去提交事务。
  • Mybatis的SQL语句是需要手写的,在程序中通过映射文件的命名空间.sql语句的id来进行调用!
  • 在Mybatis中,增删改查都是需要我们自己写SQL语句的,然后在程序中调用即可了。SQL由于是我们自己写的,于是就相对Hibernate灵活一些。
  • 如果需要传入多个参数的话,那么我们一般在映射文件中用Map来接收。
    由于我们在开发中会经常用到条件查询,Mybatis的话,我们是自己手写SQL代码的。
  • Mapper的代理方式简化开发
    • 命名空间要与JavaBean的全类名相同
    • sql片段语句的id要与Dao接口的方法名相同
    • 方法的参数和返回值要与SQL片段的接收参数类型和返回类型相同

spring【入门】

spring介绍:

Spring是一个开源框架,它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。

Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。
然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。

  • 目的:简化Java的开发
    • 基于POJO轻量级和最小侵入式开发
    • 通过依赖注入和面向接口实现松耦合
    • 基于切面和惯例进行声明式编程
    • 通过切面和模板减少样板式代码
  • 功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能
  • 范围:任何Java应用

它是一个容器框架,用来装javabean(java对象),中间层框架(万能胶)可以起一个连接作用,比如说把springMVC和Mybatis粘合在一起运用。简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

侵入式概念

Spring是一种非侵入式的框架…

侵入式

  • 对于EJB、Struts2等一些传统的框架,通常是要实现特定的接口,继承特定的类才能增强功能

    • 改变了java类的结构

    非侵入式

    • 对于Hibernate、Spring等框架,对现有的类结构没有影响,就能够增强JavaBean的功能

松耦合

一般我们在写程序的时候,都是面向接口编程,通过DaoFactroy等方法来实现松耦合

private CategoryDao categoryDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);

private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);

private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);

private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);

DAO层和Service层通过DaoFactory来实现松耦合

  • 如果Serivce层直接new DaoBook(),那么DAO和Service就紧耦合了【Service层依赖紧紧依赖于Dao】

而Spring给我们更加合适的方法来实现松耦合,并且更加灵活、功能更加强大!->IOC控制反转

切面编程

切面编程也就是AOP编程,其实我们在也接触过,动态代理就是一种切面编程了。

AOP编程可以简单理解成:在执行某些代码前,执行另外的代码

  • Struts2的拦截器也是面向切面编程【在执行Action业务方法之前执行拦截器】

Spring也为我们提供更好地方式来实现面向切面编程!

引出Spring

我们试着回顾一下没学Spring的时候,是怎么开发Web项目的

  • 实体类—>class User{ }

  • dao–> UserDao{ .. 访问db}

  • service—> UserService{ UserDao userDao = new UserDao();}

  • controller—> UserControler{UserService userService = new UserService();}

用户访问:

  • Tomcat->action->service->dao

我们来思考几个问题:

  • 1、对象创建创建能否写死?

  • 2、对象创建细节

    • controller 访问时候创建

    • service 启动时候创建

    • dao 启动时候创建

    • controller 多个

    • service 一个

    • dao 一个

    • 对象数量

    • 创建时间

  • 3、对象的依赖关系

    • controller 依赖 service

    • service依赖 dao

对于第一个问题和第三个问题,我们可以通过DaoFactory解决掉

对于第二个问题,我们要控制对象的数量和创建事件就有点麻烦了

而Spring框架通过IOC就很好地可以解决上面的问题

IOC控制反转

Spring的核心思想之一:Inversion of Control , 控制反转 IOC

那么控制反转是什么意思呢???对象的创建交给外部容器完成,这个就做控制反转。

  • Spring使用控制反转来实现对象不用在程序中写死

  • 控制反转解决对象处理问题【把对象交给别人创建】

那么对象的对象之间的依赖关系Spring是怎么做的呢??依赖注入,dependency injection.

  • Spring使用依赖注入来实现对象之间的依赖关系

  • 在创建完对象之后,对象的关系处理就是依赖注入

  • 上面已经说了,控制反转是通过外部容器完成的,而Spring又为我们提供了这么一个容器,我们一般将这个容器叫做:IOC容器.

无论是创建对象、处理对象之间的依赖关系、对象创建的时间还是对象的数量,我们都是在Spring为我们提供的IOC容器上配置对象的信息就好了。

那么使用IOC控制反转这一思想有什么作用呢?

摘取一下来自知乎的部分解释:

ioc的思想最核心的地方在于,资源不由使用资源的双方管理,而由不使用资源的第三方管理,这可以带来很多好处。第一,资源集中管理,实现资源的可配置和易管理。第二,降低了使用资源双方的依赖程度,也就是我们说的耦合度。也就是说 ,甲方要达成某种目的不需要直接依赖乙方,它只需要达到的目的告诉第三方机构就可以了,比如甲方需要一双袜子,而乙方它卖一双袜子,它要把袜子卖出去,并不需要自己去直接找到一个卖家来完成袜子的卖出。它也只需要找第三方,告诉别人我要卖一双袜子。这下好了,甲乙双方进行交易活动,都不需要自己直接去找卖家,相当于程序内部开放接口,卖家由第三方作为参数传入。甲乙互相不依赖,而且只有在进行交易活动的时候,甲才和乙产生联系。反之亦然。这样做什么好处么呢,甲乙可以在对方不真实存在的情况下独立存在,而且保证不交易时候无联系,想交易的时候可以很容易的产生联系。甲乙交易活动不需要双方见面,避免了双方的互不信任造成交易失败的问题。因为交易由第三方来负责联系,而且甲乙都认为第三方可靠。那么交易就能很可靠很灵活的产生和进行了。这就是ioc的核心思想。生活中这种例子比比皆是,支付宝在整个淘宝体系里就是庞大的ioc容器,交易双方之外的第三方,提供可靠性可依赖可灵活变更交易方的资源管理中心。另外人事代理也是,雇佣机构和个人之外的第三方。
==========================update===========================
在以上的描述中,诞生了两个专业词汇,依赖注入和控制反转所谓的依赖注入,则是,甲方开放接口,在它需要的时候,能够讲乙方传递进来(注入)所谓的控制反转,甲乙双方不相互依赖,交易活动的进行不依赖于甲乙任何一方,整个活动的进行由第三方负责管理。

  • 不用自己组装,拿来就用。

  • 享受单例的好处,效率高,不浪费空间。

  • 便于单元测试,方便切换mock组件。

  • 便于进行AOP操作,对于使用者是透明的。

  • 统一配置,便于修改。

Spring模块

Spring可以分为6大模块:

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

  • Spring Web Spring对web模块的支持。

    • 可以与struts整合,让struts的action创建交给spring

    • spring mvc模块

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

  • Spring ORM spring对orm的支持:

    • 既可以与hibernate整合,【session】

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

  • Spring AOP 切面编程

  • SpringEE spring 对javaEE其他模块的支持

上面文主要引出了为啥我们需要使用Spring框架,以及大致了解了Spring是分为六大模块的….下面主要讲解Spring的core模块!

Core模块快速入门

搭建配置环境

引入jar包:

本博文主要是core模块的内容,涉及到Spring core的开发jar包有五个:

  • 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表达式相关表

主要使用的是Spring3.2版本

编写配置文件:

Spring核心的配置文件applicationContext.xml

那这个配置文件怎么写呢??一般地,我们都知道框架的配置文件都是有约束的…我们可以在spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html找到XML配置文件的约束

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

我是使用Intellij Idea集成开发工具的,可以选择自带的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">

</beans>

前面在介绍Spring模块的时候已经说了,Core模块是:IOC容器,解决对象创建和之间的依赖关系。

因此Core模块主要是学习如何得到IOC容器,通过IOC容器来创建对象、解决对象之间的依赖关系、IOC细节。

得到Spring容器对象【IOC容器】

Spring容器不单单只有一个,可以归为两种类型

  • Bean工厂,BeanFactory【功能简单

  • 应用上下文,ApplicationContext【功能强大,一般我们使用这个】

==通过Resource获取BeanFactory==

  • 加载Spring配置文件
  • 通过XmlBeanFactory+配置文件来创建IOC容器

    //加载Spring的资源文件
    Resource resource = new ClassPathResource("applicationContext.xml");
    
    //创建IOC容器对象【IOC容器=工厂类+applicationContext.xml】
    BeanFactory beanFactory = new XmlBeanFactory(resource);
    

==类路径下XML获取ApplicationContext==

  • 直接通过ClassPathXmlApplicationContext对象来获取

    // 得到IOC容器对象
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    System.out.println(ac);
    

在Spring中总体来看可以通过三种方式来配置对象:

  • 使用XML文件配置
  • 使用注解来配置

XML配置方式

在上面我们已经可以得到IOC容器对象了。接下来就是在applicationContext.xml文件中配置信息【让IOC容器根据applicationContext.xml文件来创建对象】

* 首先我们先有个JavaBean的类

/**
 * Created by ozc on 2017/5/10.
 */
public class User {

    private String id;
    private String username;


    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

以前我们是通过new User的方法创建对象

现在我们有了IOC容器,可以让IOC容器帮我们创建对象了。在applicationContext.xml文件中配置对应的信息就行了

   <!--
使用bean节点来创建对象
id属性标识着对象
name属性代表着要创建对象的类全名
-->
<bean id="user" class="User"/>

通过IOC容器对象获取对象:

  • 在外界通过IOC容器对象得到User对象

    // 得到IOC容器对象
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    User user = (User) ac.getBean("user");
    
    System.out.println(user);
    

上面我们使用的是IOC通过无参构造函数来创建对象,我们来回顾一下一般有几种创建对象的方式:

  • 无参构造函数创建对象
  • 带参数的构造函数创建对象
  • 工厂创建对象
    • 静态方法创建对象
    • 非静态方法创建对象

使用无参的构造函数创建对象我们已经会了,接下来我们看看使用剩下的IOC容器是怎么创建对象的。

==带参数的构造函数创建对象==

首先,JavaBean就要提供带参数的构造函数:

public User(String id, String username) {
    this.id = id;
    this.username = username;
}

接下来,关键是怎么配置applicationContext.xml文件了。

<bean id="user" class="User">
    <!--通过constructor这个节点来指定构造函数的参数类型、名称、第几个-->
    <constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg>
    <constructor-arg index="1" name="username" type="java.lang.String" value="zhongfucheng"></constructor-arg>
</bean>

在constructor上如果构造函数的值是一个对象,而不是一个普通类型的值,我们就需要用到ref属性了,而不是value属性

比如说:我在User对象上维护了Person对象的值,想要在构造函数中初始化它。因此,就需要用到ref属性了

<bean id="person" class="Person"></bean> 

<bean id="user" class="User" >

    <!--通过constructor这个节点来指定构造函数的参数类型、名称、第几个-->
    <constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg>
    <constructor-arg index="1" name="username" type="java.lang.String" ref="person"></constructor-arg>
</bean>

==工厂静态方法创建对象==

首先,使用一个工厂的静态方法返回一个对象

public class Factory {

    public static User getBean() {

        return new User();
    }

}

配置文件中使用工厂的静态方法返回对象

<!--工厂静态方法创建对象,直接使用class指向静态类,指定静态方法就行了-->
<bean id="user" class="Factory" factory-method="getBean" >

</bean>

==工厂非静态方法创建对象==

首先,也是通过工厂的非静态方法来得到一个对象

public class Factory {


    public User getBean() {

        return new User();
    }


}

配置文件中使用工厂的非静态方法返回对象

<!--首先创建工厂对象-->
<bean id="factory" class="Factory"/>

<!--指定工厂对象和工厂方法-->
<bean id="user" class="User" factory-bean="factory" factory-method="getBean"/>

注解方式

通过注解来配置信息就是为了简化IOC容器的配置,注解可以把对象添加到IOC容器中、处理对象依赖关系

使用注解步骤:

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

  • @ComponentScan扫描器
  • @Configuration表明该类是配置类
  • @Component 指定把一个对象加入IOC容器—>@Name也可以实现相同的效果【一般少用】
  • @Repository 作用同@Component; 在持久层使用
  • @Service 作用同@Component; 在业务逻辑层使用
  • @Controller 作用同@Component; 在控制层使用
  • @Resource 依赖关系
    • 如果@Resource不指定值,那么就根据类型来找,相同的类型在IOC容器中不能有两个
    • 如果@Resource指定了值,那么就根据名字来找

测试代码:

  • UserDao

    package aa;
    
    import org.springframework.stereotype.Repository;
    
    /**
     * Created by ozc on 2017/5/10.
     */
    
    //把对象添加到容器中,首字母会小写
    @Repository
    public class UserDao {
    
        public void save() {
            System.out.println("DB:保存用户");
        }
    
}
  • userService

    package aa;
    
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
//把UserService对象添加到IOC容器中,首字母会小写
@Service
public class UserService {

    //如果@Resource不指定值,那么就根据类型来找--->UserDao....当然了,IOC容器不能有两个UserDao类型的对象
    //@Resource

    //如果指定了值,那么Spring就在IOC容器找有没有id为userDao的对象。
    @Resource(name = "userDao")
    private UserDao userDao;

    public void save() {
        userDao.save();
    }
}
  • userController
  • package aa;
    
    import org.springframework.stereotype.Controller;
    
    import javax.annotation.Resource;
    
    /**
     * Created by ozc on 2017/5/10.
     */
    
    //把对象添加到IOC容器中,首字母会小写
    @Controller
    public class UserController {
    
        @Resource(name = "userService")
        private UserService userService;
    
        public String execute() {
            userService.save();
            return null;
        }
    }
    
  • 测试

    package aa;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * Created by ozc on 2017/5/10.
     */
    public class App {
    
        public static void main(String[] args) {
    
            // 创建容器对象
            ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");
    
            UserAv userController = (UserController) ac.getBean("userController");
    
            userController.execute();
        }
    }
    

bean对象创建细节

在Spring第一篇中,我们为什么要引入Spring提出了这么一些问题:

  • 对象创建能否写死?
  • 对象创建细节
    • 对象数量
      • controller多个
      • service一个
      • dao一个
    • 创建时间
      • controller访问时创建
      • service启动时创建
      • dao启动时创建

既然我们现在已经初步了解IOC容器了,那么这些问题我们都是可以解决的。并且是十分简单【对象写死问题已经解决了,IOC容器就是控制反转创建对象】

==scope属性==

指定scope属性,IOC容器就知道创建对象的时候是单例还是多例的了。

属性的值就只有两个:单例/多例

  • 当我们使用singleton【单例】的时候,从IOC容器获取的对象都是同一个
  • 当我们使用prototype【多例】的时候,从IOC容器获取的对象都是不同的

scope属性除了控制对象是单例还是多例的,还控制着对象创建的时间!

  • 当使用singleton的时候,对象在IOC容器之前就已经创建了
  • 当使用prototype的时候,对象在使用的时候才创建

==lazy==-init属性

lazy-init属性只对singleton【单例】的对象有效…..lazy-init默认为false….

有的时候,可能我们想要对象在使用的时候才创建,那么将lazy-init设置为ture就行了

==init==-method和destroy-method

如果我们想要对象在创建后,执行某个方法,我们指定为init-method属性就行了。。

如果我们想要IOC容器销毁后,执行某个方法,我们指定destroy-method属性就行了。

<bean id="user" class="User" scope="singleton" lazy-init="true" init-method="" destroy-method=""/>

==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"  【在调用容器对象的destroy方法时候执行,(容器用实现类)】
 */

JAVA多线程的应用场景和目的

多线程使用的主要目的在于:

  • 吞吐量:你做WEB,容器帮你做了多线程,但是他只能帮你做请求层面的。简单的说,可能就是一个请求一个线程。或多个请求一个线程。如果是单线程,那同时只能处理一个用户的请求。

  • 伸缩性:也就是说,你可以通过增加CPU核数来提升性能。如果是单线程,那程序执行到死也就利用了单核,肯定没办法通过增加CPU核数来提升性能。

鉴于是做WEB的,第1点可能你几乎不涉及。这里就讲第二点。

举个简单的例子:
假设有个请求,这个请求服务端的处理需要执行3个很缓慢的IO操作(比如数据库查询或文件查询),那么正常的顺序可能是(括号里面代表执行时间):

  • a读取文件1 (10ms)
  • b处理1的数据(1ms)
  • c读取文件2 (10ms)
  • d处理2的数据(1ms)
  • e读取文件3 (10ms)
  • f处理3的数据(1ms)
  • g整合1、2、3的数据结果 (1ms)

单线程总共就需要34ms。
那如果你在这个请求内,把ab、cd、ef分别分给3个线程去做,就只需要12ms了。

所以多线程不是没怎么用,而是,你平常要善于发现一些可优化的点。然后评估方案是否应该使用。
假设还是上面那个相同的问题:但是每个步骤的执行时间不一样了。

  • a读取文件1 (1ms)
  • b处理1的数据(1ms)
  • c读取文件2 (1ms)
  • d处理2的数据(1ms)
  • e读取文件3 (28ms)
  • f处理3的数据(1ms)
  • g整合1、2、3的数据结果 (1ms)

单线程总共就需要34ms。
如果还是按上面的划分方案(上面方案和木桶原理一样,耗时取决于最慢的那个线程的执行速度),在这个例子中是第三个线程,执行29ms。
那么最后这个请求耗时是30ms。比起不用单线程,就节省了4ms。但是有可能线程调度切换也要花费个1、2ms。因此,这个方案显得优势就不明显了,
还带来程序复杂度提升。不太值得。

那么现在优化的点,就不是第一个例子那样的任务分割多线程完成。而是优化文件3的读取速度。
可能是采用缓存和减少一些重复读取。
首先,假设有一种情况,所有用户都请求这个请求,那其实相当于所有用户都需要读取文件3。那你想想,100个人进行了这个请求,相当于你花在读取
这个文件上的时间就是28×100=2800ms了。那么,如果你把文件缓存起来,那只要第一个用户的请求读取了,第二个用户不需要读取了,从内存取是很
快速的,可能1ms都不到。

伪代码:

public class MyServlet extends Servlet{
    private static Map<String, String> fileName2Data = new HashMap<String, String>();
    private void processFile3(String fName){
        String data = fileName2Data.get(fName);
        if(data==null){
            data = readFromFile(fName);    //耗时28ms
            fileName2Data.put(fName, data);
        }
        //process with data
    }
}

看起来好像还不错,建立一个文件名和文件数据的映射。如果读取一个map中已经存在的数据,那么就不不用读取文件了。
可是问题在于,Servlet是并发,上面会导致一个很严重的问题,死循环。因为,HashMap在并发修改的时候,可能是导致循环链表的构成!!!
(具体你可以自行阅读HashMap源码)如果你没接触过多线程,可能到时候发现服务器没请求也巨卡,也不知道什么情况!
好的,那就用ConcurrentHashMap,正如他的名字一样,他是一个线程安全的HashMap,这样能轻松解决问题。

public class MyServlet extends Servlet{
    private static ConcurrentHashMap<String, String> fileName2Data = new ConcurrentHashMap<String, String>();
    private void processFile3(String fName){
        String data = fileName2Data.get(fName);
        if(data==null){
            data = readFromFile(fName);    //耗时28ms
            fileName2Data.put(fName, data);
        }
        //process with data
    }
}

这样真的解决问题了吗,这样虽然只要有用户访问过文件a,那另一个用户想访问文件a,也会从fileName2Data中拿数据,然后也不会引起死循环。

可是,如果你觉得这样就已经完了,那你把多线程也想的太简单了,骚年!
你会发现,1000个用户首次访问同一个文件的时候,居然读取了1000次文件(这是最极端的,可能只有几百)。What the fuckin hell!!!

难道代码错了吗!

好好分析下。Servlet是多线程的,那么

public class MyServlet extends Servlet{
    private static ConcurrentHashMap<String, String> fileName2Data = new ConcurrentHashMap<String, String>();
    private void processFile3(String fName){
        String data = fileName2Data.get(fName);
        //“偶然”-- 1000个线程同时到这里,同时发现data为null
        if(data==null){
            data = readFromFile(fName);    //耗时28ms
            fileName2Data.put(fName, data);
        }
        //process with data
    }
}

上面注释的“偶然”,这是完全有可能的,因此,这样做还是有问题。

因此,可以自己简单的封装一个任务来处理。

public class MyServlet extends Servlet{

    private static ConcurrentHashMap<String, FutureTask<String>> fileName2Data = new ConcurrentHashMap<String, FutureTask<String>>();

    private static ExecutorService exec = Executors.newCachedThreadPool();


    private void processFile3(String fName){
        FutureTask<String> data = fileName2Data.get(fName);
        //“偶然”-- 1000个线程同时到这里,同时发现data为null
        if(data == null){
            data = newFutureTask(fName);
            FutureTask<String> old = fileName2Data.putIfAbsent(fName, data);
            if(old == null){
                exec.execute(data);
            }else{
                data = old;
            }
        }
        Object d = null ;
        try {
            d = data.get();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "method->processFile3" + d);
    }

    private FutureTask<String> newFutureTask(final String file){
        return  new FutureTask<String>(new Callable<String>(){
            public String call(){
                return readFromFile(file);
            }

            private String readFromFile(String file){
                System.out.println(Thread.currentThread().getName() + "method->readFromFile,do readFromFile");
                return " do readFromFile";
            }
        });
    }
}

多线程最多的场景:web服务器本身;各种专用服务器(如游戏服务器);

多线程的常见应用场景:

  • 后台任务,例如:定时向大量(100w以上)的用户发送邮件;
  • 异步处理,例如:发微博、记录日志等;
  • 分布式计算

关于对java多线程的一些基础认识

一.线程的生命周期及五种基本状态

五种基本状态

上图中基本上囊括了Java中多线程各重要知识点。掌握了上图中的各知识点,Java中的多线程也就基本上掌握了。主要包括:

Java线程具有五中基本状态

  • 新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t = new MyThread();

  • 就绪状态(Runnable):当调用线程对象的start()方法(t.start();),线程即进入就绪状态。处于就绪状态的线程,只是说明此线程已经做好了准备,随时等待CPU调度执行,并不是说执行了t.start()此线程立即就会执行;

  • 运行状态(Running):当CPU开始调度处于就绪状态的线程时,此时线程才得以真正执行,即进入到运行状态。注:就 绪状态是进入到运行状态的唯一入口,也就是说,线程要想进入运行状态执行,首先必须处于就绪状态中;

  • 阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同,阻塞状态又可以分为三种:

    • 等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;

    • 同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态;

    • 其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。

  • 死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

二. Java多线程的创建及启动

Java中线程的创建常见有如三种基本形式

1.继承Thread类,重写该类的run()方法。

class MyThread extends Thread {

    private int i = 0;

    @Override
    public void run() {
        for (i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

public class ThreadTest {

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread myThread1 = new MyThread();     // 创建一个新的线程  myThread1  此线程进入新建状态
                Thread myThread2 = new MyThread();     // 创建一个新的线程 myThread2 此线程进入新建状态
                myThread1.start();                     // 调用start()方法使得线程进入就绪状态
                myThread2.start();                     // 调用start()方法使得线程进入就绪状态
            }
        }
    }
}

如上所示,继承Thread类,通过重写run()方法定义了一个新的线程类MyThread,其中run()方法的方法体代表了线程需要完成的任务,称之为线程执行体。当创建此线程类对象时一个新的线程得以创建,并进入到线程新建状态。通过调用线程对象引用的start()方法,使得该线程进入到就绪状态,此时此线程并不一定会马上得以执行,这取决于CPU调度时机。

2.实现Runnable接口,并重写该接口的run()方法,该run()方法同样是线程执行体,创建Runnable实现类的实例,并以此实例作为Thread类的target来创建Thread对象,该Thread对象才是真正的线程对象。

class MyRunnable implements Runnable {
    private int i = 0;

    @Override
    public void run() {
        for (i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}


public class ThreadTest {

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Runnable myRunnable = new MyRunnable(); // 创建一个Runnable实现类的对象
                Thread thread1 = new Thread(myRunnable); // 将myRunnable作为Thread target创建新的线程
                Thread thread2 = new Thread(myRunnable);
                thread1.start(); // 调用start()方法使得线程进入就绪状态
                thread2.start();
            }
        }
    }
}

相信以上两种创建新线程的方式大家都很熟悉了,那么Thread和Runnable之间到底是什么关系呢?我们首先来看一下下面这个例子。

public class ThreadTest {

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Runnable myRunnable = new MyRunnable();
                Thread thread = new MyThread(myRunnable);
                thread.start();
            }
        }
    }
}

class MyRunnable implements Runnable {
    private int i = 0;

    @Override
    public void run() {
        System.out.println("in MyRunnable run");
        for (i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

class MyThread extends Thread {

    private int i = 0;

    public MyThread(Runnable runnable){
        super(runnable);
    }

    @Override
    public void run() {
        System.out.println("in MyThread run");
        for (i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

同样的,与实现Runnable接口创建线程方式相似,不同的地方在于

Thread thread = new MyThread(myRunnable);

那么这种方式可以顺利创建出一个新的线程么?答案是肯定的。至于此时的线程执行体到底是MyRunnable接口中的run()方法还是MyThread类中的run()方法呢?通过输出我们知道线程执行体是MyThread类中的run()方法。其实原因很简单,因为Thread类本身也是实现了Runnable接口,而run()方法最先是在Runnable接口中定义的方法。

public interface Runnable {

    public abstract void run();

}    

我们看一下Thread类中对Runnable接口中run()方法的实现:

@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

也就是说,当执行到Thread类中的run()方法时,会首先判断target是否存在,存在则执行target中的run()方法,也就是实现了Runnable接口并重写了run()方法的类中的run()方法。但是上述给到的列子中,由于多态的存在,根本就没有执行到Thread类中的run()方法,而是直接先执行了运行时类型即MyThread类中的run()方法。

3.使用Callable和Future接口创建线程。具体是创建Callable接口的实现类,并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象,且以此FutureTask对象作为Thread对象的target来创建线程。

看着好像有点复杂,直接来看一个例子就清晰了。

public class ThreadTest {

    public static void main(String[] args) {

        Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
                thread.start();                      //线程进入到就绪状态
            }
        }

        System.out.println("主线程for循环执行完毕..");

        try {
            int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
            System.out.println("sum = " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}


class MyCallable implements Callable<Integer> {

    private int i = 0;

    // 与run()方法不同的是,call()方法具有返回值
    @Override
    public Integer call() {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }

}

首先,我们发现,在实现Callable接口中,此时不再是run()方法了,而是call()方法,此call()方法作为线程执行体,同时还具有返回值!在创建新的线程时,是通过FutureTask来包装MyCallable对象,同时作为了Thread对象的target。那么看下FutureTask类的定义:

public class FutureTask<V> implements RunnableFuture<V> {
    //....
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

于是,我们发现FutureTask类实际上是同时实现了Runnable和Future接口,由此才使得其具有Future和Runnable双重特性。通过Runnable特性,可以作为Thread对象的target,而Future特性,使得其可以取得新创建线程中的call()方法的返回值。

执行下此程序,我们发现sum = 4950永远都是最后输出的。而“主线程for循环执行完毕..”则很可能是在子线程循环中间输出。由CPU的线程调度机制,我们知道,“主线程for循环执行完毕..”的输出时机是没有任何问题的,那么为什么sum =4950会永远最后输出呢?

原因在于通过ft.get()方法获取子线程call()方法的返回值时,当子线程此方法还未执行完毕,ft.get()方法会一直阻塞,直到call()方法执行完毕才能取到返回值。

上述主要讲解了三种常见的线程创建方式,对于线程的启动而言,都是调用线程对象的start()方法,需要特别注意的是:
不能对同一线程对象两次调用start()方法。

三. Java多线程的就绪、运行和死亡状态

  • 就绪状态转换为运行状态:当此线程得到处理器资源;

  • 运行状态转换为就绪状态:当此线程主动调用yield()方法或在运行过程中失去处理器资源。

  • 运行状态转换为死亡状态:当此线程线程执行体执行完毕或发生了异常。

此处需要特别注意的是:当调用线程的yield()方法时,线程从运行状态转换为就绪状态,但接下来CPU调度就绪状态中的哪个线程具有一定的随机性,因此,可能会出现A线程调用了yield()方法后,接下来CPU仍然调度了A线程的情况。

由于实际的业务需要,常常会遇到需要在特定时机终止某一线程的运行,使其进入到死亡状态。目前最通用的做法是设置一boolean型的变量,当条件满足时,使线程执行体快速执行完毕。如:

public class ThreadTest {

    public static void main(String[] args) {

        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                thread.start();
            }
            if(i == 40){
                myRunnable.stopThread();
            }
        }
    }
}

class MyRunnable implements Runnable {

    private boolean stop;

    @Override
    public void run() {
        for (int i = 0; i < 100 && !stop; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public void stopThread() {
        this.stop = true;
    }

}