Java Persistence with MyBatis 3(中文版) 第五章 与Spring集成

MyBatis-Spring是MyBatis框架的子模块,用来提供与当前流行的依赖注入框架Spring的无缝集成。

Spring框架是一个基于依赖注入(Dependency Injection)和面向切面编程(Aspect Oriented Programming,AOP)的Java框架,鼓励使用基于POJO的编程模型。另外,Spring提供了声明式和编程式的事务管理能力,可以很大程度上简化应用程序的数据访问层(data access layer)的实现。在本章中,我们将看到在基于Spring的应用程序中使用MyBatis并且使用Spring的基于注解的事务管理机制。

本章将包含以下话题:

  • 在Spring应用程序中配置MyBatis

安装

配置MyBatis Beans

  • 使用SqlSession
  • 使用映射器
  • 使用Spring进行事务管理

5.1 在Spring应用程序中配置MyBatis

本节将讨论如何在基于Spring的应用程序中安装和配置MyBatis。

5.1.1 安装

如果你正在使用Maven构建工具,你可以配置MyBatis的spring依赖如下:

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.2.0</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>3.1.3.RELEASE</version>
  <exclusions>
    <exclusion>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
    </exclusion>
  </exclusions>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>3.1.3.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>3.1.3.RELEASE</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjrt</artifactId>
  <version>1.6.8</version>
</dependency>
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.6.8</version>
</dependency>
<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib-nodep</artifactId>
  <version>2.2</version>
</dependency>
<dependency>
  <groupId>commons-dbcp</groupId>
  <artifactId>commons-dbcp</artifactId>
  <version>1.4</version>
</dependency>

如果你没有使用Maven,你可以从http://code.google.com/p/mybatis/上下载mybatis-spring-1.2.0-boundle.zip。将其加入,将mybatis-1.2.0.jar包添加到classpath中。

你可以从http://www.springsource.org/download/community/上下载Spring框架包spring-framework-3.1.3.RELEASE.zip。将其内所有jar包添加到classpath中。

如果你只使用MyBatis而没有使用Spring,在每一个方法中,我们需要手动创建SqlSessionFactory对象,并且从SqlSessionFactory对象中创建SqlSession。而且我们还要负责提交或者回滚事务、关闭SqlSession对象。

通过使用MyBatis-Spring模块,我们可以在Spring的应用上下文ApplicationContext中配置MyBatis Beans,Spring会负责实例化SqlSessionFactory对象以及创建SqlSession对象,并将其注入到DAO或者Service类中。并且,你可以使用Spring的基于注解的事务管理功能,不用自己在数据访问层中书写事务处理代码了。

5.1.2 配置MyBatis Beans

为了让Spring来实例化MyBatis组件如SqlSessionFactory、SqlSession、以及映射器Mapper对象,我们需要在Spring的bean配置文件中配置它们,假设在applicationContext.xml中,配配置如下:

<beans>
  <bean id="dataSource" class="org.springframework.jdbc.datasource. DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    <property name="url" value="jdbc:mysql://localhost:3306/elearning" />
    <property name="username" value="root" />
    <property name="password" value="admin" />
  </bean>
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="typeAliases" value="com.mybatis3.domain.Student, com.mybatis3.domain.Tutor" />
    <property name="typeAliasesPackage" value="com.mybatis3.domain" />
    <property name="typeHandlers" value="com.mybatis3.typehandlers.PhoneTypeHandler" />
    <property name="typeHandlersPackage" value="com.mybatis3.typehandlers" />
    <property name="mapperLocations" value="classpath*:com/mybatis3/**/*.xml" />
    <property name="configLocation" value="WEB-INF/mybatisconfig.xml" />
  </bean>
</beans>

使用上述的bean定义,Spring会使用如下配置属性创建一个SqlSessionFactory对象:

  • ? dataSource:它引用了dataSource bean
  • ? typeAliases:它指定了一系列的完全限定名的类名列表,用逗号隔开,这些别名将通过默认的别名规则创建(将首字母小写的非无完全限定类名作为别名)。
  • ? typeAliasesPackage:它指定了一系列包名列表,用逗号隔开,包内含有需要创建别名的JavaBeans。
  • ? typeHandlers:它指定了一系列的类型处理器类的完全限定名的类名列表,用逗号隔开。
  • ? typeHandlersPackage: 它指定了一系列包名列表,用逗号隔开,包内含有需要被注册的类型处理器类。
  • ? mapperLocations:它指定了SQL映射器Mapper XML配置文件的位置
  •          configLocation:它指定了MyBatisSqlSessionFactory配置文件所在的位置。

5.2 使用SqlSession

一旦SqlSessionFactory bean被配置,我们需要配置SqlSessionTemplate bean,SqlSessionTemplatebean 是一个线程安全的Spring bean,我们可以从中获取到线程安全的SqlSession对象。由于SqlSessionTemplate提供线程安全的SqlSession对象,你可以在多个Spring bean实体对象中共享SqlSessionTemplate对象。从概念上看,SqlSessionTemplate和Spring的DAO模块中的JdbcTemplate非常相似。

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
  <constructor-arg index="0" ref="sqlSessionFactory" />
</bean>

现在我肯可以将SqlSessionbean实体对象注射到任意的Springbean实体中,然后使用SqlSession对象调用SQL映射语句。

public class StudentDaoImpl implements StudentDao
{
    private SqlSession sqlSession;
    public void setSqlSession(SqlSession session)
    {
        this.sqlSession = session;
    }
    public void createStudent(Student student)
    {
        StudentMapper mapper =
            this.sqlSession.getMapper(StudentMapper.class);
        mapper.insertStudent(student);
    }
}

如果你正在使用基于XML来配置Spring beans,你可以将SqlSessionbean实体对象注射到StudenDaoImpl bean 实体对象中,如下:

<bean id="studentDao" class="com.mybatis3.dao.StudentDaoImpl">
  <property name="sqlSession" ref="sqlSession" />
</bean>

如果你使用基于注解的方式配置Spring beans,你如下将SqlSession bean实体对象注入到StudentDaoImplbean实体对象中:

@Repository
public class StudentDaoImpl implements StudentDao
{
    private SqlSession sqlSession;
    @Autowired
    public void setSqlSession(SqlSession session)
    {
        this.sqlSession = session;
    }
    public void createStudent(Student student)
    {
        StudentMapper mapper =
            this.sqlSession.getMapper(StudentMapper.class);
        mapper.insertStudent(student);
    }
}

还有另外一种注入Sqlsession对象的方法,即,通过拓展继承SqlSessionDaoSupport。这种方式让我们可以在执行映射语句时,加入任何自定义的逻辑。

public class StudentMapperImpl extends SqlSessionDaoSupport implements
    StudentMapper
{
    public void createStudent(Student student)
    {
        StudentMapper mapper =
            getSqlSession().getMapper(StudentMapper.class);
        mapper.insertAddress(student.getAddress());
        //Custom logic
        mapper.insertStudent(student);
    }
}
<bean id="studentMapper" class="com.mybatis3.dao.StudentMapperImpl">
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

在以上的这些方式中,我们注入了SqlSession对象,获取Mapper实例,然后执行映射语句。这里Spring会为我们提供一个线程安全的SqlSession对象,以及当方法结束后关闭SqlSession对象。

然而,MyBatis-Spring模块提供了更好的方式,我们可以不通过SqlSession获取映射器Mapper,直接注射Sql映射器Mapper bean。我们下节将讨论它。

5.3 使用映射器

我们可以使用MapperFactoryBean将映射器Mapper接口配置成Spring bean实体。如下所示:

public interface StudentMapper
{
    @Select("select stud_id as studId, name, email, phone from
            students where stud_id=#{id}")
    Student findStudentById(Integer id);
}
<bean id="studentMapper" class="org.mybatis.spring.mapper. MapperFactoryBean">
  <property name="mapperInterface" value="com.mybatis3.mappers. StudentMapper" />
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

现在StudentMapper bean实体对象可以被注入到任意的Spring bean实体对象中,并调用映射语句方法,如下所示:

public class StudentService
{
    private StudentMapper studentMapper;
    public void setStudentMapper (StudentMapperstudentMapper)
    {
        this. studentMapper = studentMapper;
    }
    public void createStudent(Student student)
    {
        this.studentMapper.insertStudent(student);
    }
}
<bean id="studentService" class="com.mybatis3.services. StudentService">
  <property name="studentMapper" ref="studentMapper" />
</bean>

分别配置每一个映射器Mapper接口是一个非常单调的过程。我们可以使用MapperScannerConfigurer来扫描包(package)中的映射器Mapper接口,并自动地注册。

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="basePackage" value="com.mybatis3.mappers" />
</bean>

如果映射器Mapper接口在不同的包(package)中,你可以为basePackage属性指定一个以逗号分隔的包名列表。

MyBatis-Spring-1.2.0介绍了两种新的扫描映射器Mapper接口的方法:

  • l   使用<mybatis:scan/>元素
  • l   使用@MapperScan注解(需Spring3.1+版本)

5.3.1 <mybatis:scan />

<mybatis:scan>元素将在特定的以逗号分隔的包名列表中搜索映射器Mapper接口。使用这个新的MyBatis-Spring名空间你需要添加以下的schema声明:

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://mybatis.org/schema/mybatis-spring
        http://mybatis.org/schema/mybatis-spring.xsd">
    <mybatis:scan base-package="com.mybatis3.mappers" />
</beans>

<mybatis:scan>元素提供了下列的属性来自定义扫描过程:

  • annotation: 扫描器将注册所有的在base-package包内并且匹配指定注解的映射器Mapper接口。
  • factory-ref:当Spring上下文中有多个SqlSessionFactory实例时,需要指定某一特定的SqlSessionFactory来创建映射器Mapper接口。正常情况下,只有应用程序中有一个以上的数据源才会使用。
  • ? marker-interface: 扫描器将注册在base-package包中的并且继承了特定的接口类的映射器Mapper接口
  • ? template-ref: 当Spring上下文中有多个SqlSessionTemplate实例时,需要指定某一特定的SqlSessionTemplate来创建映射器Mapper接口。正常情况下,只有应用程序中有一个以上的数据源才会使用。
  •          name-generator:BeannameGenerator类的完全限定类名,用来命名检测到的组件。

5.3.2 MapperScan

Spring 框架3.x+版本支持使用@Configuration和@Bean 注解来提供基于Java 的配置。如果你倾向于使用基于Java的配置,你可以使用@MapperScan注解来扫描映射器Mapper接口。@MapperScan和<mybatis:scan/>工作方式相同,并且也提供了对应的自定义选项。

@Configuration
@MapperScan("com.mybatis3.mappers")
public class AppConfig
{
    @Bean
    public DataSource dataSource()
    {
        return new PooledDataSource("com.mysql.jdbc.Driver",
                                    "jdbc:mysql://localhost:3306/elearning", "root", "admin");
    }
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception
    {
        SqlSessionFactoryBeansessionFactory = new
        SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        return sessionFactory.getObject();
    }
}

@MapperScan注解有以下属性供自定义扫描过程使用:

? annotationClass: 扫描器将注册所有的在base-package包内并且匹配指定注解的映射器Mapper接口。

? markerInterface: 扫描器将注册在base-package包中的并且继承了特定的接口类的映射器Mapper接口

? sqlSessionFactoryRef:当Spring 上下文中有一个以上的SqlSesssionFactory时,用来指定特定SqlSessionFactory

? sqlSessionTemplateRef: 当Spring 上下文中有一个以上的sqlSessionTemplate时,用来指定特定sqlSessionTemplate

? nameGenerator:BeanNameGenerator类用来命名在Spring容器内检测到的组件。

? basePackageClasses:basePackages()的类型安全的替代品。包内的每一个类都会被扫描。

? basePackages:扫描器扫描的基包,扫描器会扫描内部的Mapper接口。注意包内的至少有一个方法声明的才会被注册。具体类将会被忽略。

5.4 使用Spring进行事务管理

只使用MyBatis,你需要写事务控制相关代码,如提交或者回退数据库操作。

public Student createStudent(Student student)
{
    SqlSession sqlSession = MyBatisUtil.getSqlSessionFactory().
                            openSession();
    try
    {
        StudentMapper mapper =
            sqlSession.getMapper(StudentMapper.class);
        mapper.insertAddress(student.getAddress());
        mapper.insertStudent(student);
        sqlSession.commit();
        return student;
    }
    catch (Exception e)
    {
        sqlSession.rollback();
        throw new RuntimeException(e);
    }
    finally
    {
        sqlSession.close();
    }
}

我们可以使用Spring的基于注解的事务处理机制来避免书写上述的每个方法中控制事务的冗余代码。

为了能使用Spring的事务管理功能,我们需要在Spring应用上下文中配置TransactionManagerbean实体对象:

<bean id="transactionManager"
    class="org.springframework.jdbc. datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource" />
</bean>

事务管理器引用的dataSource和SqlSessionFactory bean使用的dataSource相同。

在Spring中使用基于注解的事务管理特性,如下:

<tx:annotation-driven transaction-manager="transactionManager"/>

现在你可以在Spring service bean上使用@Transactional注解,表示在此service中的每一个方法都应该在一个事务中运行。如果方法成功运行完毕,Spring会提交操作。如果有运行期异常发生,则会执行回滚操作。另外,Spring会将MyBatis 的异常转换成合适的DataAccessExceptions,这样会为特定错误上提供额外的信息。

@Service
@Transactional
public class StudentService
{
    @Autowired
    private StudentMapper studentMapper;
    public Student createStudent(Student student)
    {
        studentMapper.insertAddress(student.getAddress());
        if(student.getName().equalsIgnoreCase(""))
        {
            throw new RuntimeException("Student name should not be
                                       empty.");
        }
        studentMapper.insertStudent(student);
        return student;
    }
}

下面是一个Spring的applicationContext.xml完成配置:

<beans>
  <context:annotation-config />
  <context:component-scan base-package="com.mybatis3" />
  <context:property-placeholder location="classpath:application.properties" />
  <tx:annotation-driven transaction-manager="transactionManager" />
  <bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
  </bean>
  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.mybatis3.mappers" />
  </bean>
  <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg index="0" ref="sqlSessionFactory" />
  </bean>
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="typeAliases"
value="com.mybatis3.domain.Student,com.mybatis3.domain.Tutor" />
    <property name="typeAliasesPackage" value="com.mybatis3.domain" />
    <property name="typeHandlers" value="com.mybatis3.typehandlers.PhoneTypeHandler" />
    <property name="typeHandlersPackage" value="com.mybatis3.typehandlers" />
    <property name="mapperLocations" value="classpath*:com/mybatis3/**/*.xml" />
  </bean>
  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="${jdbc.driverClassName}"></property>
    <property name="url" value="${jdbc.url}"></property>
    <property name="username" value="${jdbc.username}"></property>
    <property name="password" value="${jdbc.password}"></property>
  </bean>
</beans>

现在让我们写一个独立的测试客户端来测试StudentService,如下:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml"
                     )
public class StudentServiceTest
{
    @Autowired
    private StudentService studentService;
    @Test
    public void testCreateStudent()
    {
        Address address = new Address(0, "Quaker Ridge
                                      Rd.", "Bethel", "Brooklyn", "06801", "USA");
        Student stud = new Student();
        long ts = System.currentTimeMillis();
        stud.setName("stud_" + ts);
        stud.setEmail("stud_" + ts + "@gmail.com");
        stud.setAddress(address);
        Student student = studentService.createStudent(stud);
        assertNotNull(student);
        assertEquals("stud_" + ts, student.getName());
        assertEquals("stud_" + ts + "@gmail.com", student.getEmail());
        System.err.println("CreatedStudent: " + student);
    }
    @Test(expected = DataAccessException.class)
    public void testCreateStudentForException()
    {
        Address address = new Address(0, "Quaker Ridge
                                      Rd.", "Bethel", "Brooklyn", "06801", "USA");
        Student stud = new Student();
        long ts = System.currentTimeMillis();
        stud.setName("Timothy");
        stud.setEmail("stud_" + ts + "@gmail.com");
        stud.setAddress(address);
        studentService.createStudent(stud);
        fail("You should not reach here");
    }
}

这里在testCreateStudent()方法中,我们为Address和Student赋上了合适的数据,所以Address和Student会被分别插入到表ADDRESSES和STUDENTS中。在testCreateStudentForException()方法我们设置了名字为Timothy,该名称在数据库中已经存在了,所以当你尝试将此student记录插入到数据库中,MySQL会抛出一个UNIQUE
KEY 冲突的异常,Spring会将此异常转换成DataAccessException异常,并且将插入ADDRESSES表中的数据回滚(rollback)掉。

5.5 总结

在本章中我们学习了怎样将MyBatis与Spring框架集成。我们还学习了怎样安装Spring类库并且在Spring 的应用上下文ApplicationContext上注册MyBatis bean实体对象。我们还看到怎样配置和注入SqlSession和Mapper bean实体对象以及调用映射语句。我们还学习了利用Spring基于注解的事务处理机制来使用MyBatis。

你已经读完本书,祝贺你!现在,你应该知道怎样高效地使用MyBatis与数据库工作。你学会了怎样发挥你的Java和SQL技巧的优势使MyBatis更富有成效。你知道了怎样以更清晰的方式使用MyBatis写出数据持久化代码,不用管被MyBatis框架处理的所有底层细节。另外,你学会了怎样在最流行的依赖注入框架-Spring中使用MyBatis。

MyBatis框架非常易于使用,但它提供了强大的特性,因此它对于基于Java的项目而言,是一个非常好的数据库持久化解决方案。MyBatis也提供了一些工具如MyBatis Generator(http://www.mybatis.org/generator/),可以被用来从已经存在的数据库schema中,产生持久化代码如数据库实体(databaseentities),映射器Mapper 接口,MapperXML配置文件,使MyBatis入门非常方便。另外,MyBatis还有它的姊妹项目如MyBatis.NET和MyBatis-Scala,分别为.NET
和Scala编程语言提供了一样强大的特性。

MyBatis随着每一个版本的发布,增加了一些特性,正变得越来越好。想了解更多的新特性,你可以访问MyBatis官方网站https://code.google.com/p/mybatis/.订阅MyBatis 的使用者邮件列表是一个不错的想法。我们祝你一切顺利,编码快乐!(We
wish you all the best, and happy coding!)

《Java Persistence with MyBatis 3(中文版)》导航:

Java Persistence with MyBatis 3(中文版)

Java Persistence with MyBatis 3(中文版) 前言

Java Persistence with MyBatis 3(中文版) 第一章 MyBatis入门

Java Persistence with MyBatis 3(中文版) 第二章 引导MyBatis

Java Persistence with MyBatis 3(中文版) 第三章 使用XML配置SQL映射器

Java Persistence with MyBatis 3(中文版) 第四章 使用注解配置SQL映射器

Java Persistence with MyBatis 3(中文版) 第五章 与Spring集成

-----------------------------------------------------------------------------------------------------------------------

作者声明:本文出处是http://blog.csdn.net/luanlouis,如需转载,请注明出处!

Java Persistence with MyBatis 3(中文版) 第五章 与Spring集成,布布扣,bubuko.com

时间: 2024-10-13 17:39:16

Java Persistence with MyBatis 3(中文版) 第五章 与Spring集成的相关文章

Java Persistence with MyBatis 3(中文版) 第四章 使用注解配置SQL映射器

在上一章,我们看到了我们是怎样在映射器Mapper XML配置文件中配置映射语句的.MyBatis也支持使用注解来配置映射语句.当我们使用基于注解的映射器接口时,我们不再需要在XML配置文件中配置了.如果你愿意,你也可以同时使用基于XML和基于注解的映射语句. 本章将涵盖以下话题: l 在映射器Mapper接口上使用注解 l 映射语句 @Insert,@Update,@Delete,@SeelctStatements l 结果映射 一对一映射 一对多映射 l 动态SQL @SelectProvi

Java Persistence with MyBatis 3(中文版) 第三章 使用XML配置SQL映射器

关系型数据库和SQL是经受时间考验和验证的数据存储机制.和其他的ORM 框架如Hibernate不同,MyBatis鼓励开发者可以直接使用数据库,而不是将其对开发者隐藏,因为这样可以充分发挥数据库服务器所提供的SQL语句的巨大威力.与此同时,MyBaits消除了书写大量冗余代码的痛苦,它使使用SQL更容易. 在代码里直接嵌套SQL语句是很差的编码实践,并且维护起来困难.MyBaits使用了映射器配置文件或注解来配置SQL语句.在本章中,我们会看到具体怎样使用映射器配置文件来配置映射SQL语句.

Java Persistence with MyBatis 3(中文版)

译者的话 前段时间由于工作和学习的需要,我打算深入研究MyBatis框架.于是在网上查找关于MyBatis的教程,发现国内网上关于MyBatis的教程资料少得可怜:除了MyBatis官网上的用户使用手册外,就没有比较系统地讲述MyBatis的教程了. 无意间发现了这本<JavaPersistence with MyBatis 3>,它比较全面地讲述了MyBatis框架.感叹于国内MyBatis资料比较匮乏,故而鼓起勇气自不量力地尝试将此书翻译成中文,希望能够对国内的MyBatis用户有所帮助.

Java Persistence with MyBatis 3(中国版) 第五章 与Spring集成

MyBatis-Spring它是MyBatis子模块框.它用来提供流行的依赖注入框架Spring无缝集成. Spring框架是一个基于依赖注入(Dependency Injection)和面向切面编程(Aspect Oriented Programming,AOP)的Java框架,鼓舞使用基于POJO的编程模型. 另外,Spring提供了声明式和编程式的事务管理能力.能够非常大程度上简化应用程序的数据訪问层(data access layer)的实现.在本章中,我们将看到在基于Spring的应用

Java Persistence with MyBatis 3(中文版) 第二章 引导MyBatis

MyBatis最关键的组成部分是SqlSessionFactory,我们可以从中获取SqlSession,并执行映射的SQL语句.SqlSessionFactory对象可以通过基于XML的配置信息或者Java API 创建. 我们将探索各种MaBatis配置元素,如dataSource,environments,全局参数设置,typeAlias,typeHandlers,SQL映射:接着我们将实例化SqlSessionFactory. 本章将涵盖一下内容: l  使用 XML配置MyBatis

Java Persistence with MyBatis 3(中文版) 前言

对很多软件系统而言,保存数据到数据库和从数据库中检索数据是其工作流程中至关重要的一部分.在 Java 领域,有很多的实现了数据持久化层的工具和框架,它们每一个都有自己不同的实现方法.而 MyBatis,一个简单但功能强大的 Java 持久化框架,则采用了消除冗余代码和充分利用 SQL 和 Java 自身提供的强大的特性的策略. 这本MyBatis 教程将带你经历 MyBatis的安装.配置和使用这几个过程.每一章涉及到的概念将通过简单而实用的例子配合详细的指导来解释. 在本书的最后,你不仅会学到

Java Persistence with MyBatis 3(中文版) 第一章 MyBatis入门

本章将涵盖以下话题: ž  MyBatis是什么? ž  为什么选择MyBatis? ž  MyBatis安装配置 ž  域模型样例 1.1 MyBatis是什么 MyBatis是一个简化和实现了Java数据持久化层(persistencelayer)的开源框架,它抽象了大量的JDBC冗余代码,并提供了一个简单易用的API和数据库交互. MyBatis的前身是iBATIS,iBATIS于2002年由ClintonBegin创建.MyBatis 3 是iBATIS的全新设计,支持注解和Mapper

《Java并发编程实战》第十五章 原子变量与非阻塞同步机制 读书笔记

一.锁的劣势 锁定后如果未释放,再次请求锁时会造成阻塞,多线程调度通常遇到阻塞会进行上下文切换,造成更多的开销. 在挂起与恢复线程等过程中存在着很大的开销,并且通常存在着较长时间的中断. 锁可能导致优先级反转,即使较高优先级的线程可以抢先执行,但仍然需要等待锁被释放,从而导致它的优先级会降至低优先级线程的级别. 二.硬件对并发的支持 处理器填写了一些特殊指令,例如:比较并交换.关联加载/条件存储. 1 比较并交换 CAS的含义是:"我认为V的值应该为A,如果是,那么将V的值更新为B,否则不需要修

Java基础知识二次学习--第五章 数组

第五章 数组 时间:2017年4月26日15:11:30~2017年4月26日15:15:54 章节:05章_01节  视频长度:09:30 内容:一维数组的内存分析 心得: Java中数组是引用类型 栈里面存的数组的引用 实际对象在堆内存里面 (C与C++是分配在栈里的) 内存图: 元素为引用数据类型的数组 引用类型的数组如上图 时间:2017年4月26日15:16:22~2017年4月26日15:19:00 章节:05章_02节  视频长度:05:25 内容:数组元素的创建与使用 心得: 首