Spring +dubbo +mybatis

最新推荐文章于 2024-04-26 20:19:53 发布

持之以恒的骚年

最新推荐文章于 2024-04-26 20:19:53 发布

阅读量4k

点赞数 1

分类专栏： dubbo设计文章标签： spring dubbo mabatis 整合 generate

本文链接：https://blog.csdn.net/lz1012793721/article/details/52712131

版权

dubbo设计专栏收录该内容

2 篇文章 0 订阅

订阅专栏

spring以及dubbo配置
首先导入相关jar包，在web.xml中添加配置Spring监听

<context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
             applicationContext.xml
        </param-value>
    </context-param>
    <listener>     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
   </web-app>

在本项目中src/dubbo-cfg添加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" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <!-- 引入配置文件 -->
    <context:property-placeholder ignore-unresolvable="true" location="classpath:/dubbo-cfg/dubbo-prop/dubbo-cfg.properties" />
    <!-- 引入mybatis数据库配置文件 -->
    <context:property-placeholder ignore-unresolvable="true" location="classpath:/dubbo-cfg/dubbo-prop/mybatisJdbc.properties" />
    <!-- 注册注解-->
    <context:annotation-config/> 
    <!-- 对事物进行代理 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    <!-- 扫描业务层实现类 -->
    <context:component-scan base-package="com.belle.dubbo.provider.api.impl"/>
    <!-- 导入mybatis的bean-->
    <import resource="spring-mybatis.xml"/>
    <!-- 初始化applicaionContext工具类 -->
    <bean id="springUtil" class="com.belle.dubbo.util.SpringUtil" />

    <!-- 消费方应用名，用于计算依赖关系  -->
    <dubbo:application name="${dubbo.application.name}" />
    <!-- 使用zookeeper注册中心暴露服务地址 -->
    <dubbo:registry protocol="zookeeper" address="${dubbo.registry.address.hr}" />
    <!-- 用dubbo协议在${gds.dubbo.port}端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="${oa.dubbo.port}" />
    <dubbo:consumer timeout="${dubbo.consumer.timeout}"	retries="${dubbo.consumer.retries}" />
    <dubbo:provider timeout="${dubbo.provider.timeout}"	retries="${dubbo.provider.retries}" />
    <!-- 配置消费方-->
    <import resource="dubbo-consumer.xml" /> 

    <!-- 提供方配置 -->
    <import resource="dubbo-provider.xml"/>
</beans>

src/dubbo-cfg/dubbo-prop包下：dubbo-cfg.properties

#dubbo conf
dubbo.application.name=OA-Provider-HR
dubbo.registry.address.hr=172.17.210.152\:2181,172.17.210.153\:2181,172.17.210.154\:2181
dubbo.provider.timeout=10000
dubbo.provider.retries=0
dubbo.consumer.timeout=10000
dubbo.consumer.retries=0
oa.dubbo.port=20880
# other system service dubbo version
dubbo.oa.api.version=1.0.0

src/dubbo-cfg/dubbo-prop包下：mybatisJdbc.properties

ojdbc.driver= oracle.jdbc.driver.OracleDriver
ojdbc.url= jdbc:oracle:thin:@172.17.194.43:1521:OADEV6
ojdbc.username=bloa
ojdbc.password=zbbloa
ojdbc.maxActive=50
mybatis.mappers=classpath\:/dubbo-cfg/mybatis-cfg.xml

src/dubbo-cfg包下：spring-mybatis.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" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd 
    http://www.springframework.org/schema/tx   
    http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 配置数据源 -->
    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${ojdbc.driver}"/>      
        <property name="url" value="${ojdbc.url}"/>
        <property name="username" value="${ojdbc.username}"/>
        <property name="password" value="${ojdbc.password}"/>
    </bean>
    <!-- 配置数据工厂 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 自动扫描mapper.xml文件 -->
        <property name="mapperLocations" value="classpath:/com/belle/dubbo/mapperXml/*.xml"/>
        <property name="dataSource" ref="dataSource" />
    </bean>
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <property name="basePackage" value="com.belle.dubbo.mapper"></property>
    </bean>
    <!-- 配置事物管理器 -->
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 开启事物的注解模式 -->
    <tx:annotation-driven transaction-manager="transactionManager" />
</beans>

dubbo接口的设计
dubbo接口的提供方与消费方配置

<?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"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">



    <!-- 声明需要暴露的服务接口 -->
    <bean id="dubboServiceImpl" class="com.belle.dubbo.provider.api.impl.DubboServiceImpl" />
    <!-- 和本地bean一样实现服务-->
    <dubbo:service interface="com.belle.dubbo.provider.api.DubboService" ref="dubboServiceImpl"  version="${dubbo.oa.api.version}" /> 
</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"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">


    <!--消费方接口调用

    <dubbo:reference id="lzDubbo" interface="com.belle.dubbo.provier.api.LzDubbo" version="${dubbo.oa.api.version}" check="false" />   -->
</beans>

Service层
提供方接口放在src /com/belle/dubbo/provider/api 包下

package com.belle.dubbo.provider.api;

import java.util.List;

import com.belle.dubbo.dto.HrmResource;

public interface DubboService {
    int insert(HrmResource record);

    List<HrmResource> selectAll();

    HrmResource selectHrmReById(int Id);
}

提供方接口实现类src /com/belle/dubbo/provider/api/impl

package com.belle.dubbo.provider.api.impl;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.transaction.annotation.Transactional;

import weaver.general.BaseBean;

import com.belle.dubbo.dto.HrmResource;
import com.belle.dubbo.mapper.HrmResourceMapper;
import com.belle.dubbo.provider.api.DubboService;

@Transactional
public class DubboServiceImpl implements DubboService {
    @Resource(name = "hrmResourceMapper")
    private HrmResourceMapper hrmResourceMapper;

    @Override
    public int insert(HrmResource record) {
        hrmResourceMapper.insert(record);
        return 0;
    }

    @Override
    public List<HrmResource> selectAll() {

        return hrmResourceMapper.selectAll();
    }

    @Override
    public HrmResource selectHrmReById(int Id) {
        // TODO Auto-generated method stub
         BaseBean bs = new BaseBean();
         bs.writeLog("DubboServiceImpl :id="+Id);
         return hrmResourceMapper.selectHrmReById(Id);

    }
}

获取bean工具

package com.belle.dubbo.util;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class SpringUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;
    /**
     * 实现ApplicationContextAware接口的回调方法，设置上下文环境
     * 
     * @param applicationContext
     */
    public void setApplicationContext(ApplicationContext applicationContext) {
        SpringUtil.applicationContext = applicationContext;
    }

    /**
     * @return ApplicationContext
     */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 获取对象
     * @param name
     * @return Object
     * @throws BeansException
     */
    public static Object getBean(String name) throws BeansException {
        return applicationContext.getBean(name);
    }
}

事物
事物的控制位于service层，原由：
（1）web层事务，这一般是针对那些安全性要求较高的系统来说的。
（2）service层事务，这是一常见的事务划分，将事务设置在业务逻辑上，只要业务逻辑出错或异常就事务回滚。
（3）数据持久层数据务，也就是常说的数据库事务。这种事务在安全性方面要求低。就是给一个简单的增删改之类的操作增加事务操作。
给Service层配置事务，因为一个Service层方法操作可以关联到多个mapper的操作。在Service层执行这些mapper操作，多mapper操作有失败全部回滚，成功则全部提交。

service层与Mapper（DAO）层
通过Spring的注解将mapper注入到ServiceImpl中，service是业务层，dao是数据访问层。业务逻辑的实现在service层完成，数据持久化操作则在Dao层完成，实现业务逻辑的解耦。
事物（基于注解的使用）用法
MyBatis自动参与到spring事务管理中，无需额外配置，只要org.mybatis.spring.SqlSessionFactoryBean引用的数据源与DataSourceTransactionManager引用的数据源一致即可，否则事务管理会不起作用。
@Transactional属性
属性类型描述
value String 可选的限定描述符，指定使用的事务管理器
propagation enum: Propagation 可选的事务传播行为设置
isolation enum: Isolation 可选的事务隔离级别设置
readOnly boolean 读写或只读事务，默认读写
timeout int (in seconds granularity) 事务超时时间设置
rollbackFor Class对象数组，必须继承自Throwable 导致事务回滚的异常类数组
rollbackForClassName 类名数组，必须继承自Throwable 导致事务回滚的异常类名字数组
noRollbackFor Class对象数组，必须继承自Throwable 不会导致事务回滚的异常类数组
noRollbackForClassName 类名数组，必须继承自Throwable 不会导致事务回滚的异常类名字数组
@Transactional 可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有 public 方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义。
虽然 @Transactional 注解可以作用于接口、接口方法、类以及类方法上，但是 Spring 建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。另外， @Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。如果你在 protected、private 或者默认可见性的方法上使用 @Transactional 注解，这将被忽略，也不会抛出任何异常。
默认情况下，只有来自外部的方法调用才会被AOP代理捕获，也就是，类内部方法调用本类内部的其他方法并不会引起事务行为，即使被调用方法使用@Transactional注解进行修饰。

mapper(Dao)层
在Spring容器启动读取mapper.xml文件.

<?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>
    <settings>
        <!-- 启用自动将数据库字段和pojo中的字段做驼峰式的匹配 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 懒加载模式 -->
        <setting name="lazyLoadingEnabled" value="false" />
        <!-- JdbcType enumeration. Most common are: NULL, VARCHAR and OTHER -->
        <setting name="jdbcTypeForNull" value="NULL" />
        <setting name="defaultStatementTimeout" value="30" />
    </settings>
    <mappers>
        <!-- 加载映射 -->
        <mapper resource="com/belle/dubbo/mapperXml/HrmResourceMapper.xml" />
    </mappers>
</configuration>

在src/com/belle/dubbo/mapperXml 包下的mapper.xml 实现与mapper关联

<?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" >
<mapper namespace="com.belle.dubbo.mapper.HrmResourceMapper" >
  <resultMap id="BaseResultMap" type="com.belle.dubbo.dto.HrmResource" />
  <insert id="insert" parameterType="com.belle.dubbo.dto.HrmResource" />
  <select id="selectAll" resultMap="BaseResultMap" >SELECT T.* FROM HRMRESOURCE T WHERE ID &lt;=100;
  </select>
  <select id="selectHrmReById" parameterType="Integer" resultMap="BaseResultMap" >SELECT T.* FROM HRMRESOURCE T WHERE T.ID = #{id}
  </select>
</mapper>

通过namespace=”com.belle.dubbo.mapperXml.HrmResourceMapper”与mapper关联

maaper.xml中的标签以及简单sql编写
http://www.mybatis.org/mybatis-3/zh/java-api.html

Mapper XML 文件
MyBatis 的真正强大在于它的映射语句，也是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 就是针对 SQL 构建的，并且比普通的方法做的更好。
SQL 映射文件有很少的几个顶级元素（按照它们应该被定义的顺序）：
• cache – 给定命名空间的缓存配置。
• cache-ref – 其他命名空间缓存配置的引用。
• resultMap – 是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。
• parameterMap – 已废弃！老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除，这里不会记录。
• sql – 可被其他语句引用的可重用语句块。
• insert – 映射插入语句
• update – 映射更新语句
• delete – 映射删除语句
• select – 映射查询语句
下一部分将从语句本身开始来描述每个元素的细节。
select
查询语句是 MyBatis 中最常用的元素之一，光能把数据存到数据库中价值并不大，如果还能重新取出来才有用，多数应用也都是查询比修改要频繁。对每个插入、更新或删除操作，通常对应多个查询操作。这是 MyBatis 的基本原则之一，也是将焦点和努力放到查询和结果映射的原因。简单查询的 select 元素是非常简单的。比如：

SELECT * FROM PERSON WHERE ID = #{id}

这个语句被称作 selectPerson，接受一个 int（或 Integer）类型的参数，并返回一个 HashMap 类型的对象，其中的键是列名，值便是结果行中的对应值。
注意参数符号：

{id}

这就告诉 MyBatis 创建一个预处理语句参数，通过 JDBC，这样的一个参数在 SQL 中会由一个“?”来标识，并被传递到一个新的预处理语句中，就像这样：
// Similar JDBC code, NOT MyBatis…
String selectPerson = “SELECT * FROM PERSON WHERE ID=?”;
PreparedStatement ps = conn.prepareStatement(selectPerson);
ps.setInt(1,id);
当然，这需要很多单独的 JDBC 的代码来提取结果并将它们映射到对象实例中，这就是 MyBatis 节省你时间的地方。我们需要深入了解参数和结果映射，细节部分我们下面来了解。
select 元素有很多属性允许你配置，来决定每条语句的作用细节。

{property,javaType=int,jdbcType=NUMERIC}

像 MyBatis 的剩余部分一样，javaType 通常可以从参数对象中来去确定，前提是只要对象不是一个 HashMap。那么 javaType 应该被确定来保证使用正确类型处理器。
NOTE 如果 null 被当作值来传递，对于所有可能为空的列，JDBC Type 是需要的。你可以自己通过阅读预处理语句的 setNull() 方法的 JavaDocs 文档来研究这种情况。
为了以后定制类型处理方式，你也可以指定一个特殊的类型处理器类（或别名），比如：

{age,javaType=int,jdbcType=NUMERIC,typeHandler=MyTypeHandler}

尽管看起来配置变得越来越繁琐，但实际上是很少去设置它们。
对于数值类型，还有一个小数保留位数的设置，来确定小数点后保留的位数。

{height,javaType=double,jdbcType=NUMERIC,numericScale=2}

最后，mode 属性允许你指定 IN，OUT 或 INOUT 参数。如果参数为 OUT 或 INOUT，参数对象属性的真实值将会被改变，就像你在获取输出参数时所期望的那样。如果 mode 为 OUT（或 INOUT），而且 jdbcType 为 CURSOR(也就是 Oracle 的 REFCURSOR)，你必须指定一个 resultMap 来映射结果集到参数类型。要注意这里的 javaType 属性是可选的，如果左边的空白是 jdbcType 的 CURSOR 类型，它会自动地被设置为结果集。

{department, mode=OUT, jdbcType=CURSOR, javaType=ResultSet, resultMap=departmentResultMap}

MyBatis 也支持很多高级的数据类型，比如结构体，但是当注册 out 参数时你必须告诉它语句类型名称。比如（再次提示，在实际中要像这样不能换行）：

{middleInitial, mode=OUT, jdbcType=STRUCT, jdbcTypeName=MY_TYPE, resultMap=departmentResultMap}

尽管所有这些强大的选项很多时候你只简单指定属性名，其他的事情 MyBatis 会自己去推断，最多你需要为可能为空的列名指定 jdbcType。

{firstName}

{middleInitial,jdbcType=VARCHAR}

{lastName}

字符串替换
默认情况下,使用#{}格式的语法会导致 MyBatis 创建预处理语句属性并安全地设置值（比如?）。这样做更安全，更迅速，通常也是首选做法，不过有时你只是想直接在 SQL 语句中插入一个不改变的字符串。比如，像 ORDER BY，你可以这样来使用：
ORDER BY ${columnName}
这里 MyBatis 不会修改或转义字符串。
NOTE 以这种方式接受从用户输出的内容并提供给语句中不变的字符串是不安全的，会导致潜在的 SQL 注入攻击，因此要么不允许用户输入这些字段，要么自行转义并检验。
Result Maps
resultMap 元素是 MyBatis 中最重要最强大的元素。它就是让你远离 90%的需要从结果集中取出数据的 JDBC 代码的那个东西, 而且在一些情形下允许你做一些 JDBC 不支持的事情。事实上, 编写相似于对复杂语句联合映射这些等同的代码, 也许可以跨过上千行的代码。 ResultMap 的设计就是简单语句不需要明确的结果映射,而很多复杂语句确实需要描述它们的关系。
你已经看到简单映射语句的示例了,但没有明确的 resultMap。比如:

select id, username, hashedPassword
from some_table
where id = #{id}

这样一个语句简单作用于所有列被自动映射到 HashMap 的键上,这由 resultType 属性指定。这在很多情况下是有用的,但是 HashMap 不能很好描述一个领域模型。那样你的应用程序将会使用 JavaBeans 或 POJOs(Plain Old Java Objects,普通 Java 对象)来作为领域模型。MyBatis 对两者都支持。看看下面这个 JavaBean:
package com.someapp.model;
public class User {
private int id;
private String username;
private String hashedPassword;

public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getHashedPassword() {
return hashedPassword;
}
public void setHashedPassword(String hashedPassword) {
this.hashedPassword = hashedPassword;
}
}
基于 JavaBean 的规范,上面这个类有 3 个属性:id,username 和 hashedPassword。这些在 select 语句中会精确匹配到列名。
这样的一个 JavaBean 可以被映射到结果集,就像映射到 HashMap 一样简单。

select id, username, hashedPassword
from some_table
where id = #{id}

要记住类型别名是你的伙伴。使用它们你可以不用输入类的全路径。比如:

select id, username, hashedPassword
from some_table
where id = #{id}

这些情况下,MyBatis 会在幕后自动创建一个 ResultMap,基于属性名来映射列到 JavaBean 的属性上。如果列名没有精确匹配,你可以在列名上使用 select 字句的别名(一个基本的 SQL 特性)来匹配标签。比如:

select
user_id as “id”,
user_name as “userName”,
hashed_password as “hashedPassword”
from some_table
where id = #{id}

ResultMap 最优秀的地方你已经了解了很多了,但是你还没有真正的看到一个。这些简单的示例不需要比你看到的更多东西。只是出于示例的原因, 让我们来看看最后一个示例中外部的 resultMap 是什么样子的,这也是解决列名不匹配的另外一种方式。

引用它的语句使用 resultMap 属性就行了(注意我们去掉了 resultType 属性)。比如:

select user_id, user_name, hashed_password
from some_table
where id = #{id}

如果世界总是这么简单就好了。
高级结果映射
MyBatis 创建的一个想法:数据库不用永远是你想要的或需要它们是什么样的。而我们最喜欢的数据库最好是第三范式或 BCNF 模式,但它们有时不是。如果可能有一个单独的数据库映射,所有应用程序都可以使用它,这是非常好的,但有时也不是。结果映射就是 MyBatis 提供处理这个问题的答案。
比如,我们如何映射下面这个语句?

select
B.id as blog_id,
B.title as blog_title,
B.author_id as blog_author_id,
A.id as author_id,
A.username as author_username,
A.password as author_password,
A.email as author_email,
A.bio as author_bio,
A.favourite_section as author_favourite_section,
P.id as post_id,
P.blog_id as post_blog_id,
P.author_id as post_author_id,
P.created_on as post_created_on,
P.section as post_section,
P.subject as post_subject,
P.draft as draft,
P.body as post_body,
C.id as comment_id,
C.post_id as comment_post_id,
C.name as comment_name,
C.comment as comment_text,
T.id as tag_id,
T.name as tag_name
from Blog B
left outer join Author A on B.author_id = A.id
left outer join Post P on B.id = P.blog_id
left outer join Comment C on P.id = C.post_id
left outer join Post_Tag PT on PT.post_id = P.id
left outer join Tag T on PT.tag_id = T.id
where B.id = #{id}

你可能想把它映射到一个智能的对象模型,包含一个作者写的博客,有很多的博文,每篇博文有零条或多条的评论和标签。下面是一个完整的复杂结果映射例子 (假设作者, 博客, 博文, 评论和标签都是类型的别名) 我们来看看, 。但是不用紧张, 我们会一步一步来说明。当天最初它看起来令人生畏,但实际上非常简单。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" 
    "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >

<!-- 此文件只是mybatis 的数据库自动生成映射文件，实体类，接口等方法的，发布时，不用提交此文件，也可删除 -->

<generatorConfiguration>
    <!-- 引用的jdbc的类路径，这里将jdbc jar和generator的jar包放在一起了 -->
    <classPathEntry location="C:\\ojdbc6.jar" />
    <context id="DB2Tables" targetRuntime="MyBatis3Simple">

        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
            <property name="suppressDate" value="false" /> <!-- 是否生成注释代时间戳 -->
        </commentGenerator>

        <!-- 指定的jdbc的连接信息 -->
        <jdbcConnection driverClass="oracle.jdbc.driver.OracleDriver"
            connectionURL="jdbc:oracle:thin:@172.17.194.43:1521:OADEV6" userId="bloa"
            password="zbbloa" />

        <!-- 类型转换 -->
        <javaTypeResolver>
            <!-- 是否使用bigDecimal， false可自动转化以下类型（Long, Integer, Short, etc.） -->
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!-- 生成实体类地址 Model -->
        <javaModelGenerator targetPackage="com.belle.dubbo.dto"
            targetProject="LzFactory2Provider\src">
            <!-- 是否在当前路径下新加一层schema,eg：fase路径com.oop.eksp.user.model， true:com.oop.eksp.user.model.[schemaName] -->
            <property name="enableSubPackages" value="false" />
            <!-- 是否针对string类型的字段在set的时候进行trim调用 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>

        <!-- 生成map.xml文件 XML -->
        <sqlMapGenerator targetPackage="com.belle.dubbo.dao.mapper"
            targetProject="LzFactory2Provider\src">
            <!-- 是否在当前路径下新加一层schema,eg：fase路径com.oop.eksp.user.model， true:com.oop.eksp.user.model.[schemaName] -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>

        <!-- 生成map.xml对应client，也就是接口DAO -->
        <javaClientGenerator targetPackage="com.belle.dubbo.dao"
            targetProject="LzFactory2Provider\src" type="XMLMAPPER">
            <!--是否在当前路径下新加一层schema,eg：fase路径com.oop.eksp.user.model， true:com.oop.eksp.user.model.[schemaName] -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>

        <!-- schema：数据库名 tableName：对应的数据库表 domainObjectName：要生成的实体类 enable*ByExample： 
            是否生成 example类 -->
        <table schema="bloa" tableName="hrmresource" domainObjectName="HrmResource"
            enableCountByExample="false" enableDeleteByExample="false"
            enableSelectByExample="false" enableUpdateByExample="false">
        </table>

    </context>
</generatorConfiguration>

持之以恒的骚年

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Spring +dubbo +mybatis

spring以及dubbo配置首先导入相关jar包，在web.xml中添加配置Spring监听<context-param> <param-name>contextConfigLocation</param-name> <param-value> applicationContext.xml </param-value>
复制链接

扫一扫