当前位置：首页 > article >正文

MyBatis SQL 映射文件基础

article 2025/1/8 23:46:31

一、MyBatis SQL 映射文件简介

在 Java 持久层框架的广阔天地里，MyBatis 无疑是一颗璀璨的明星，备受开发者青睐。它宛如一座坚固的桥梁，巧妙地连接着 Java 应用程序与数据库，让数据的交互变得顺畅无阻。而在 MyBatis 的体系架构中，SQL 映射文件更是扮演着举足轻重的角色，犹如一位幕后英雄，默默支撑着整个数据访问层的高效运转。

SQL 映射文件，简单来说，就是存放 SQL 语句的关键所在，它承载着 Java 对象与数据库表之间沟通的使命。通过将 SQL 语句从繁杂的 Java 代码中剥离出来，独立存储于 XML 文件中，MyBatis 为我们带来了诸多显著优势。一方面，代码的耦合度大幅降低，使得程序结构更加清晰，易于维护。当 SQL 语句需要调整时，无需在浩如烟海的 Java 代码中苦苦寻觅，只需在对应的映射文件中精准修改，如同在有序的文档库中查找资料，高效便捷。另一方面，这种分离为 SQL 调优开辟了绿色通道。开发人员可以专注于 SQL 语句的优化，尽情施展数据库调优的技巧，而不用担心影响到其他业务逻辑代码，为提升系统性能提供了有力保障。

二、核心元素全解析

（一）<mapper>标签：命名空间的定义者

在深入探究 MyBatis SQL 映射文件的奇妙世界时，我们首先会邂逅至关重要的<mapper>标签。它宛如一座巍峨大厦的基石，作为整个映射文件的根元素，承载着不可或缺的使命。其核心属性namespace，更是起着关键的命名空间定义作用，犹如为每个 Mapper 文件赋予了独一无二的身份证。通过将namespace精准设置为对应的 Mapper 接口全限定名，MyBatis 能够在茫茫代码海洋中，迅速而准确地建立起 SQL 语句与 Java 方法之间的紧密关联。这种一一对应的绑定关系，就像是为数据的交互搭建了一条条专属的高速通道，确保了操作的精准性与高效性。当我们在大型项目中穿梭，面对众多繁杂的 Mapper 文件时，namespace的独特标识作用愈发凸显，它能让我们轻松定位到目标代码，极大地提升了代码的可维护性与可读性。

（二）<select>元素：查询语句的载体

在 MyBatis 的 SQL 映射文件里，<select>标签无疑是一颗闪耀的明星，肩负着承载查询语句的重任。它就像一位精准的导航员，引领着我们从数据库的浩瀚海洋中获取所需的数据。

先来看它的诸多属性，各个都有着独特的作用。其中，id属性宛如标签的身份证号，必须具备唯一性，它与 Mapper 接口中的方法名精准对应，使得 Java 代码在调用时能够迅速找到目标查询语句，就像在电话簿中通过姓名快速定位联系人一样便捷。parameterType属性则像是一座桥梁，负责指定传入参数的类型，让 Java 数据能够顺利地过渡到 SQL 语句的世界中，无论是简单的基本数据类型，还是复杂的自定义对象，它都能完美适配，确保数据传递的准确性。而resultType和resultMap属性，如同两位风格迥异的设计师，掌控着查询结果的呈现形式。resultType擅长简洁明了，当查询结果能够直接映射到简单的 Java 对象，如常见的String、Integer，或是拥有简单属性的自定义实体类时，它便能大显身手，自动完成数据的封装，将数据库中的记录迅速转化为可用的 Java 对象，就像把原材料直接加工成标准化的成品。而resultMap则像是一位精细的工匠，专为处理复杂的映射关系而生。当数据库表的字段名与 Java 对象的属性名不完全匹配，或是涉及到多表关联查询，结果集中包含了复杂的嵌套对象时，resultMap便能发挥其强大的定制化映射能力，通过精心配置，将每一个字段都精准地安置到对应的 Java 对象属性中，确保数据的完整性与准确性。

举个生动的例子，假设我们有一个简单的用户信息查询场景，只需要获取用户的姓名和年龄，且数据库表字段与 Java 对象属性完全一致，此时使用resultType便能轻松搞定：

<select id="getUserNameAndAge" parameterType="int" resultType="com.example.User">

select name, age from user where id = #{id}

</select>

而在另一个复杂的业务场景中，我们需要查询订单信息以及关联的用户信息、商品信息，涉及多表关联，字段名也不尽相同，这时resultMap就会挺身而出，通过细致的配置，将复杂的数据完美地映射到对应的 Java 对象中，构建出完整的业务模型，满足系统对数据的精准需求。

（三）<insert>、<update>、<delete>元素：数据变更的执行者

<insert>、<update>、<delete>这三个元素，如同三位英勇的战士，在 MyBatis 的世界里肩负着执行数据变更操作的重任，它们的结构有着诸多相似之处，都围绕着对数据库数据的增、改、删核心任务而设计。

以<insert>为例，它身上有着一些独特的属性，在特定场景下发挥着关键作用。useGeneratedKeys和keyProperty这两个属性组合，就像是一对默契的搭档，专为应对主键生成的情况而生。当我们使用的数据库支持主键自动生成，如 MySQL 的自增主键时，将useGeneratedKeys设置为true，就像是打开了一扇获取主键值的大门，MyBatis 会自动启用 JDBC 的相关机制，在数据插入成功后，精准地获取到由数据库内部生成的主键值。而keyProperty则像是一个精准的导航标，明确指定这个获取到的主键值应该映射到 Java 对象的哪个属性中，确保数据的一致性与完整性，方便后续业务逻辑对主键的引用。

下面通过一些具体示例，来看看它们在实际应用中的强大威力。在用户注册功能中，使用<insert>标签插入新用户数据：

<insert id="addUser" parameterType="com.example.User" useGeneratedKeys="true" keyProperty="id">

insert into user (name, password, email) values (#{name}, #{password}, #{email})

</insert>

这段代码清晰地展示了如何在插入用户数据的同时，巧妙获取自动生成的主键值，并将其赋值给用户对象的id属性。而在更新用户信息时，<update>标签大显身手：

<update id="updateUserInfo" parameterType="com.example.User">

update user set name = #{name}, password = #{password}, email = #{email} where id = #{id}

</update>

它能够精准地根据传入的用户对象，将对应的信息更新到数据库中，确保数据的及时性与准确性。当需要删除用户数据时，<delete>标签简洁而有力：

<delete id="deleteUserById" parameterType="int">

delete from user where id = #{id}

</delete>

只需指定要删除的用户id，就能迅速从数据库中清理掉对应的记录，维护数据的整洁性。这些示例充分展现了这三个元素在数据变更操作中的高效与便捷，是构建健壮数据层的得力工具。

（四）<sql>元素：可复用 SQL 片段的容器

<sql>标签宛如一位智慧的工匠，在 MyBatis 的世界里精心打造着可重用的 SQL 模块。它允许我们将那些频繁出现在 SQL 语句中的公共部分，如通用的字段列表、复杂的查询条件片段等，巧妙地提取出来，封装成一个个独立的、可复用的 SQL 块。就像是将建筑中的通用组件提前预制好，随时等待组装。

而<include>标签，则像是一把神奇的钥匙，能够开启复用之门。它可以在其他 SQL 语句中灵活引用由<sql>标签定义的 SQL 片段，通过简单的配置，将这些预制好的组件精准地嵌入到需要的地方，实现代码的高度复用。这种复用机制带来的好处是显而易见的，它不仅极大地提高了代码的编写效率，避免了重复劳动，还使得代码的维护变得更加轻松愉悦。当业务需求发生变化，需要调整公共 SQL 部分时，我们只需在<sql>标签定义处进行修改，所有引用该片段的地方都会同步更新，仿佛牵一发而动全身，确保了数据操作的一致性。

例如，在一个多表关联查询的复杂场景中，我们需要频繁查询多个表的公共字段。此时，就可以利用<sql>标签定义一个包含这些公共字段的 SQL 片段：

<sql id="commonColumns">

a.id, a.name, b.age, c.address

</sql>

然后，在具体的查询语句中，通过<include>标签轻松引用：

<select id="getComplexData" resultType="com.example.ComplexResult">

select <include refid="commonColumns"/>

from table_a a

inner join table_b b on a.id = b.a_id

inner join table_c c on a.id = c.a_id

where a.status = #{status}

</select>

通过这种方式，复杂的 SQL 语句变得简洁明了，易于管理，为高效的数据查询奠定了坚实基础。

（五）<resultMap>元素：复杂映射的解决方案

<resultMap>标签犹如一位精密的映射大师，在 MyBatis 的舞台上展现着强大的定制化映射能力。它专为应对那些复杂的数据映射场景而设计，当数据库查询结果无法直接简单映射到 Java 对象时，<resultMap>便能挺身而出，发挥其独特的魔力。

剖析<resultMap>标签的内部结构，会发现它包含了诸多精妙的子元素，每个子元素都有着明确的分工。constructor元素像是一位精准的建筑师，它能够根据查询结果，巧妙地调用 Java 对象的构造方法进行实例化，通过指定参数的顺序和类型，精准地构建出符合业务需求的对象实例。association元素则像是一位细腻的红娘，专注于处理一对一的关联关系，比如在查询用户信息时，关联查询用户的详细地址信息，它能够将地址对象精准地嵌入到用户对象中，构建出完整的用户资料模型。collection元素宛如一位高效的收纳大师，擅长处理一对多的关联场景，例如查询部门信息时，一并获取该部门下的所有员工信息，它能够将多个员工对象有序地收纳进一个集合中，方便后续业务逻辑的处理。

在实际的复杂查询场景中，这些子元素的协同作用展现出了无与伦比的魅力。以一个经典的电商订单查询为例，查询一个订单时，不仅需要获取订单的基本信息，还需要关联查询下单用户的详细信息，以及订单包含的多个商品详情。此时，<resultMap>标签便能精心构建出一个复杂而精准的映射关系：

<resultMap id="orderResultMap" type="com.example.Order">

<id property="id" column="order_id"/>

<result property="orderNo" column="order_no"/>

<result property="createTime" column="create_time"/>

<association property="user" javaType="com.example.User">

<id property="id" column="user_id"/>

<result property="username" column="username"/>

<result property="email" column="email"/>

</association>

<collection property="orderItems" ofType="com.example.OrderItem">

<id property="id" column="item_id"/>

<result property="productName" column="product_name"/>

<result property="quantity" column="quantity"/>

</collection>

</resultMap>

<select id="getOrderById" resultMap="orderResultMap">

select o.order_id, o.order_no, o.create_time,

u.user_id, u.username, u.email,

i.item_id, i.product_name, i.quantity

from orders o

left join users u on o.user_id = u.user_id

left join order_items i on o.order_id = i.order_id

where o.order_id = #{id}

</select>

在这段代码中，<resultMap>通过巧妙配置，将来自多个表的字段精准地映射到了Order对象及其关联的User对象、OrderItem集合中，构建出了一个完整的订单业务模型，为电商系统的订单管理提供了强大的数据支持，充分展现了 MyBatis 在复杂数据处理方面的卓越能力。

三、参数传递与取值的门道

（一）单个参数传递

在 MyBatis 的世界里，单个参数传递是最基础的操作之一。当我们面对的是单个基本类型参数，比如一个简单的int型用户id，在 SQL 映射文件的<select>语句中，使用#{参数名}就能轻松获取参数值，此时参数名可以随意书写，因为 MyBatis 能够自动识别。就像这样：

<select id="getUserById" parameterType="int" resultType="com.example.User">

select * from user where id = #{anyName}

</select>

这里的anyName无论写成什么，只要在对应的 Mapper 接口方法中传入正确的int型参数，MyBatis 都能准确地将其与 SQL 语句中的占位符对应起来，从数据库中捞出对应id的用户信息。

而当参数为引用类型，例如一个包含用户各种属性的User对象时，情况稍有不同。此时，在 SQL 语句里必须使用对象的属性名来取值，即#{属性名}。假设User对象有username和password属性，我们要根据用户名查询用户信息，代码如下：

<select id="getUserByUsername" parameterType="com.example.User" resultType="com.example.User">

select * from user where username = #{username}

</select>

MyBatis 会通过反射机制，精准地从传入的User对象中获取username属性的值，用以构建查询条件，确保数据查询的准确性。这种灵活又严谨的参数传递机制，为不同场景下的数据交互提供了便利。

（二）多个参数传递

当涉及多个参数传入 SQL 语句时，MyBatis 有着独特的处理方式。如果不做任何特殊处理，MyBatis 会将多个参数自动封装成一个Map，其中Map的键默认是arg0、arg1…… 或者param1、param2…… ，值就是对应的参数值。但这种默认方式在实际开发中存在弊端，可读性较差，开发人员很难直接从键名看出对应参数的含义。

为了解决这个问题，MyBatis 提供了@Param注解。通过在 Mapper 接口方法的参数前添加@Param("指定的key值")，MyBatis 会将参数封装进Map时，使用我们指定的key值，使得 SQL 语句中的参数取值更加清晰易懂。比如，我们要根据用户的id和username查询用户信息，使用@Param注解的代码如下：

public interface UserMapper {

User getUserByIdAndUsername(@Param("id") int id, @Param("username") String username);

}

对应的 SQL 映射文件：

<select id="getUserByIdAndUsername" resultType="com.example.User">

select * from user where id = #{id} and username = #{username}

</select>

这样，无论是开发人员后续维护代码，还是阅读代码逻辑，都能一目了然地知道每个参数的用途，大大提高了代码的可读性与可维护性。在实际项目中，面对多个参数的情况，建议优先使用@Param注解，为代码的稳健性和协作性保驾护航。

（三）参数取值方式：#{} 与 ${} 的差异

在 MyBatis 的 SQL 映射文件中，参数取值有两种至关重要的方式：#{}与${}，它们虽看似相近，实则有着天壤之别。

#{}是一种预编译的取值方式，它就像是一位严谨的卫士，能有效防止 SQL 注入攻击。当使用#{}时，MyBatis 在底层会将参数部分用?占位符代替，在预编译阶段才将参数值设置进去，确保参数值被安全地嵌入到 SQL 语句中。例如：

<select id="getUserByName" resultType="com.example.User">

select * from user where name = #{name}

</select>

假设传入的name值为'Tom'，实际执行的 SQL 语句在预编译后会变成类似select * from user where name =?，然后将'Tom'作为参数值传入，这样即使传入的参数包含恶意 SQL 片段，如'; DROP TABLE user; --，MyBatis 也能将其作为普通字符串处理，避免了 SQL 注入的风险，保障了数据库的安全。

而${}则是直接拼接取值的方式，它更像是一位直来直去的工匠，将参数值直接拼接到 SQL 语句中。例如：

<select id="getUserByTableName" resultType="com.example.User">

select * from ${tableName} where id = #{id}

</select>

如果传入的tableName值为'user'，生成的 SQL 语句就是select * from user where id =?。但这种方式存在巨大的安全隐患，因为参数未经任何处理直接拼接，如果参数可控且被恶意篡改，就极易引发 SQL 注入问题。

不过，${}也并非一无是处，它在某些特定场景下有着不可替代的作用。当我们需要动态传入表名、列名等数据库对象时，由于这些对象在 SQL 语法中不能被预编译，只能使用${}进行拼接。比如，在分表查询的场景下，根据不同的时间范围查询不同的数据表：

<select id="getOrderByTimeRange" resultType="com.example.Order">

select * from ${tableName} where create_time between #{startTime} and #{endTime}

</select>

这里的tableName如果是根据业务规则动态生成的，如order_202301、order_202302等，就必须使用${}来确保 SQL 语句的正确性。

总之，在日常开发中，为了保障系统安全，应优先使用#{}进行参数取值。只有在遇到必须动态传入表名、列名等特殊情况时，才谨慎使用${}，并且要对传入的参数进行严格的校验与过滤，避免 SQL 注入漏洞的出现，确保数据交互的安全与稳定。

四、实战演练：从理论到实践的跨越

（一）搭建环境

在开启 MyBatis 的实战之旅前，精心搭建一个稳定且合适的开发环境至关重要，这是后续所有操作的基石。

我们首先创建一个 Maven 项目，在项目的pom.xml文件中引入 MyBatis 以及相关依赖，确保项目具备强大的数据库交互能力。以下是关键的依赖配置片段：

<dependencies>

<dependency>

<groupId>org.mybatis</groupId>

<artifactId>mybatis</artifactId>

<version>3.5.7</version>

</dependency>

<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>8.0.26</version>

</dependency>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>4.13.2</version>

<scope>test</scope>

</dependency>

</dependencies>

紧接着，配置 MyBatis 的核心文件mybatis-config.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>

<environments default="development">

<environment id="development">

<transactionManager type="JDBC"/>

<dataSource type="POOLED">

<property name="driver" value="com.mysql.cj.jdbc.Driver"/>

<property name="url" value="jdbc:mysql://localhost:3306/mydb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=UTF-8&useAffectedRows=true"/>

<property name="username" value="root"/>

<property name="password" value="123456"/>

</dataSource>

</environment>

</environments>

<mappers>

<mapper resource="com/example/mapper/UserMapper.xml"/>

</mappers>

</configuration>

在这个配置中，我们明确指定了连接的 MySQL 数据库的详细信息，包括驱动、URL、用户名和密码，同时精准加载了对应的 SQL 映射文件，为后续的数据交互搭建好了稳固的桥梁。

（二）简单查询实例

环境搭建完毕后，让我们通过一个简单的查询用户信息案例，来深入体会 MyBatis 的强大之处。

首先，定义一个实体类User，它如同数据库表在 Java 世界中的 “代言人”，精准反映表的结构：

public class User {

private Long id;

private String username;

private String password;

private Integer age;

// 省略getter和setter方法

}

接着，在 Mapper 接口UserMapper中定义查询方法：

public interface UserMapper {

User getUserById(Long id);

}

随后，在 SQL 映射文件UserMapper.xml中编写对应的<select>语句：

<?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.example.mapper.UserMapper">

<select id="getUserById" parameterType="java.lang.Long" resultType="com.example.User">

select id, username, password, age from user where id = #{id}

</select>

</mapper>

万事俱备，编写测试类来验证我们的代码：

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import org.junit.Test;

import java.io.IOException;

import java.io.InputStream;

public class MyBatisTest {

@Test

public void testGetUserById() throws IOException {

String resource = "mybatis-config.xml";

InputStream inputStream = Resources.getResourceAsStream(resource);

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

SqlSession sqlSession = sqlSessionFactory.openSession();

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

User user = userMapper.getUserById(1L);

System.out.println(user.getUsername());

sqlSession.close();

}

运行测试方法，如果一切顺利，控制台将输出对应id为 1 的用户的用户名，这标志着我们成功地通过 MyBatis 从数据库中获取到了期望的数据，完成了一次简单而又关键的查询操作。

（三）复杂查询与数据变更实例

在实际项目中，除了简单查询，复杂查询与数据变更操作更是家常便饭。接下来，我们设计一个多表关联查询与插入数据的综合实例，进一步展现 MyBatis 的强大实力。

假设有用户表user、订单表order和商品表product，它们之间存在着紧密的关联关系。我们要查询某个用户的所有订单信息，以及每个订单所包含的商品详情。

首先，创建相应的实体类：

public class Order {

private Long id;

private Long userId;

private String orderNo;

private List<Product> products;

// 省略getter和setter方法

}

public class Product {

private Long id;

private String productName;

private BigDecimal price;

// 省略getter和setter方法

}

在 Mapper 接口OrderMapper中定义查询方法：

public interface OrderMapper {

Order getOrderByUserId(Long userId);

}

然后，在 SQL 映射文件OrderMapper.xml中利用<resultMap>和<association>、<collection>等元素编写复杂的查询语句：

<?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.example.mapper.OrderMapper">

<resultMap id="orderResultMap" type="com.example.Order">

<id property="id" column="o_id"/>

<result property="userId" column="user_id"/>

<result property="orderNo" column="order_no"/>

<collection property="products" ofType="com.example.Product">

<id property="id" column="p_id"/>

<result property="productName" column="product_name"/>

<result property="price" column="price"/>

</collection>

</resultMap>

<select id="getOrderByUserId" resultMap="orderResultMap">

select o.id as o_id, o.user_id, o.order_no, p.id as p_id, p.product_name, p.price

from `order` o

left join order_item oi on o.id = oi.order_id

left join product p on oi.product_id = p.id

where o.user_id = #{userId}

</select>

</mapper>

编写测试方法验证：

@Test

public void testGetOrderByUserId() throws IOException {

String resource = "mybatis-config.xml";

InputStream inputStream = Resources.getResourceAsStream(resource);

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

SqlSession sqlSession = sqlSessionFactory.openSession();

OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);

Order order = orderMapper.getOrderByUserId(1L);

System.out.println(order.getOrderNo());

for (Product product : order.getProducts()) {

System.out.println(product.getProductName());

}

sqlSession.close();

}

运行测试，将能清晰看到用户的订单编号以及订单下的商品名称列表，成功实现复杂的多表关联查询。

再来看一个插入数据的示例，在UserMapper.xml中新增插入用户的<insert>语句：

<insert id="addUser" parameterType="com.example.User" useGeneratedKeys="true" keyProperty="id">

insert into user (username, password, age) values (#{username}, #{password}, #{age})

</insert>

在测试类中编写插入测试方法：

@Test

public void testAddUser() throws IOException {

String resource = "mybatis-config.xml";

InputStream inputStream = Resources.getResourceAsStream(resource);

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

SqlSession sqlSession = sqlSessionFactory.openSession(true);

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

User user = new User();

user.setUsername("new_user");

user.setPassword("123456");

user.setAge(25);

userMapper.addUser(user);

System.out.println("插入用户的id: " + user.getId());

sqlSession.close();

}

运行该测试，数据将成功插入数据库，同时控制台会打印出由数据库自动生成并回填到用户对象的id值，完成一次完整的数据插入操作，充分展示了 MyBatis 在复杂业务场景下的数据处理能力。

五、总结与拓展

至此，我们已深入探索了 MyBatis SQL 映射文件的基础领域，揭开了其神秘面纱的一角。通过对核心元素如<mapper>、<select>、<insert>等的详细剖析，我们明晰了它们在构建稳固数据访问层时的关键职责与独特魅力。参数传递与取值的技巧，无论是单个参数的灵活运用，还是多个参数的精准处理，乃至#{}与${}的巧妙抉择，都为我们编写高效、安全的 SQL 语句提供了有力保障。实战演练环节更是将理论转化为实践，让我们真切感受到 MyBatis 在实际项目中的强大效能。

然而，这仅仅是 MyBatis 世界的开篇。前方还有更多高级特性等待我们去征服，动态 SQL 犹如一位灵动的舞者，能根据不同业务场景动态拼接出精准的 SQL 语句，让数据查询更加智能高效；缓存机制则像一位默默守护的卫士，通过合理配置，可大幅提升查询性能，减轻数据库压力；还有延迟加载、拦截器等强大功能，每一个都蕴含着无限潜力，等待我们在后续学习与实践中去挖掘、去运用，助力我们成为 MyBatis 领域的行家里手，打造出更加卓越的数据库驱动应用。

查看全文

http://www.kler.cn/a/472201.html