源程序(中文注释),自动映射生成最终执行的

作者: www.9159.com  发布:2019-11-09

 

动态SQL

动态sql,主要用于解决查询条件不确定的情况:在程序运行期间,根据用户提交的查询条件进行查询。提交的查询条件不同,执行的sql语句不同。若将每种可能的情况均逐一列出,对所有条件进行排列组合,将会出现大量的sql语句。此时,可使用动态sql来解决这样的问题

www.9159.com 1

用户自定义查询.PNG

动态sql,即通过MyBatis提供的各种标签对条件作出判断以实现拼接sql语句

这里的条件判断使用的表达式为OGNL表达式。常用的动态SQL标签有<if>、<where>、<choose/>、<foreach>等。

1.实体类:

public class Student {

    private Integer id;
    private String name;
    private int age;
    private double score;
    //无参构造器与带参构造器
    //getter 和 setter
    //toString()
}

2.测试类

public class MyTest {

    private IStudentDao dao;
    private SqlSession session;

    @Before
    public void setUp(){
        session = MyBatisUtils.getSqlSession();
        dao = session.getMapper(IStudentDao.class);
    }

    @After
    public void tearDown(){
        if(session!=null){
            session.close();
        }
    }
}

注意事项:

在mapper的动态sql中若出现大于号(>)、小于号(<)、大于等于号(>=)、小于等于号(<=)等符号,最好将其转换为实体符号。否则,xml可能会出现解析出错问题。

www.9159.com 2

替换规则.PNG

1.<if/>标签

对于该标签的执行,当test的值为true时,会将其包含的sql片段拼接到其后所在的sql语句中。

例:查询出满足用户提交查询条件的所有学生。用户提交的查询条件可以包含一个姓名的模糊查询,同时还可以包含一个年龄的下限。当然,用户在提交表单时可能两个条件均作出了设定,也可能两个条件均不做设定,也可以只做其中一项设定。

查询条件不确定,查询条件依赖于用户提交的内容。此时,就可使用动态sql语句,根据用户提交内容对将要执行的sql进行拼接。

dao接口:

public interface IStudentDao {      
    List<Student> selectStudentsIf(Student student) 
}

映射文件:

<select id="selectStudentsIf" resultType="Student">
    select * from student
    where 1=1
    <if test="name !=null and name!=''">
        and name like '%' #{name} '%'
    </if>
    <if test="age > 0">
        and age > #{age}
    </if>
</select>

测试类:

@Test
public void test01(){
    Student student = new Student();
    List<Student> students = dao.selectStudentsIf(student);
    System.out.println(students);
}

2.<where/>标签

dao接口:

public interface IStudentDao {

    List<Student> selectStudentsIf(Student student);
    List<Student> selectStudentsWhere(Student student);
}

映射文件:

<select id="selectStudentsWhere" resultType="Student">
    select * from student
    <where>
        <if test="name!=null and name!=''">
            and name like '%' #{name} '%'
        </if>
        <if test="age > 0">
            and age > #{age}
        </if>
    </where>
</select>

测试:

@Test
public void test02(){
    Student student = new Student();
    List<Student> students = dao.selectStudentsWhere(student);
    System.out.println(students);
}

3.<choose/>标签

该标签只可以包含<when/><otherwise/>,可以包含多个<when/>与一个<otherwise/>。他们联合使用,完成java中的开关语句switch..case功能。

需求:若姓名不空,则按姓名查询;若姓名为空,则按年龄查询;若没有查询条件,则没有查询结果。

dao接口:

public interface IStudentDao {

    List<Student> selectStudentsIf(Student student);
    List<Student> selectStudentsWhere(Student student);
    List<Student> selectStudentsChoose(Student student);
}

映射文件:

对于<choose/>标签,其会从第一个<when/>开始逐个向后进行条件判断。若出现<when/>中的test属性值为true的情况,则直接结束<choose/>标签,不再向后进行判断查找。若所有<when/>的test判断结果均为false,则最后会执行<otherwise/>标签。

<select id="selectStudentsChoose" resultType="Student">
    select * from student
    <where>
        <choose>
            <when test="name!=null and name!=''">
                and name like '%' #{name} '%'
            </when>
            <when test="age>0">
                and age < #{age}
            </when>
            <otherwise>
                and 1 != 1
            </otherwise>
        </choose>
    </where>
</select>

测试类:

@Test
public void test03(){
    Student student = new Student();
    List<Student> students = dao.selectStudentsChoose(student);
    System.out.println(students);
}

4.<foreach/>标签--遍历数组

<foreach/>标签用于实现对于数组于集合的遍历。对其使用,需要注意:

  • collection表示要遍历的集合类型,这里是数组,即array
  • open、close、separator为对遍历内容的SQL拼接

dao接口:

public interface IStudentDao {

    List<Student> selectStudentsIf(Student student);
    List<Student> selectStudentsWhere(Student student);
    List<Student> selectStudentsChoose(Student student);
    List<Student> selectStudentsForeachArray(Object[] studentIds);
}

映射文件

动态sql的判断中使用的都是OGNL表达式。OGNL表达式中的数组使用array表示,数组长度使用array.length表示。

<select id="selectStudentsForeachArray" resultType="Student">
    select * from student
    <if test="array !=null and array.length >0">
        where id in
        <foreach collection="array" open="(" close=")" item="myid" separator=",">
            #{myid}
        </foreach>
    </if>
</select>

www.9159.com 3

foreach标签.PNG

测试类:

@Test
public void test04(){   
    Object[] studentIds = new Object[]{1,3};
    List<Student> students = dao.selectStudentsForeachArray(studentIds);
    System.out.println(students);
}

5.<foreach/>标签--遍历泛型为基本类型的List

dao接口:

public interface IStudentDao {

    List<Student> selectStudentsIf(Student student);
    List<Student> selectStudentsWhere(Student student);
    List<Student> selectStudentsChoose(Student student);
    List<Student> selectStudentsForeachArray(Object[] studentIds);
    List<Student> selectStudentsForeachList(List<Integer> studentIds);
}

映射文件:

OGNL表达式中的List使用list表示,其大小使用list.size表示。

<select id="selectStudentsForeachList" resultType="Student">
    select * from student
    <if test="list!=null and list.size > 0">
        where id in
        <foreach collection="list"  open="(" close=")" item="myid" separator=",">
            #{myid}
        </foreach>
    </if>
</select>

测试类:

@Test
public void test05(){
    List<Integer> studentIds = new ArrayList<Integer>();
    student.add(1);
    student.add(3);

    List<Student> students = dao.selectStudentsForeachList(studentIds);
    System.out.println(students);   
}

6.<foreach/>标签--遍历泛型为自定义类型的List

dao接口:

List<Student> selectStudentsForeachList2(List<Student> students);

映射文件:

注意,这里的当前遍历对象类型是List中的泛型,即是Student对象。

<select id="selectStudentsForeachList2" resultType="Student">
    <!-- select * from student where id in(1,3) -->
    select * from student
    <if test="list!=null and list.size > 0">
        where id in
        <foreach collection="list"  open="(" close=")" item="stu" separator=",">
            #{stu.id}
        </foreach>
    </if>
</select>

测试类:

@Test
public void test09(){
    Student student1 = new Student();
    student1.setId(1);
    Student student3 = new Student();
    student3.setId(3);

    List<Student> students = new ArrayList<Student>();
    students.add(student1);
    students.add(student3);

    students = dao.selectStudentsForeachList2(students);
    System.out.println(students);
}

7.<sql/>标签

<sql/>标签用于定义sql片段,以便其它sql标签复用。而其他标签使用该SQL片段,需要使用<include/>子标签。该<sql/>标签可以定义SQL语句中的任何部分,所以<include/>子标签可以放在动态sql的任何位置

dao接口:

List<Student> selectStudentsBySQLFragment(List<Student> students);

映射文件:

www.9159.com 4

使用sql片段.PNG

测试类:

@Test
public void test09(){
    Student student1 = new Student();
    student1.setId(1);
    Student student3 = new Student();
    student3.setId(3);

    List<Student> students = new ArrayList<Student>();
    students.add(student1);
    students.add(student3);

    students = dao.selectStudentsBySQLFragment(students);
    System.out.println(students);
}

     <mapper resource="sqlmap/User.xml"/>

源程序(中文注释)

<span style="font-size:16px;font-weight:bold;">
摘要:
在mssql中,一条sql语句默认为一个事务,下文展示如何在一条sql语句中,插入多行数据
</span>
<hr />
例:  

单表的CURD操作(使用mapper动态代理)

MyBatis框架抛开dao的实现类,直接定位到映射文件mapper的相应sql语句,对DB进行操作。这种dao的实现方式成为mapper的动态代理方式。

mapper动态代理方式无需程序员实现dao接口。接口是由MyBatis结合映射文件自动生成的动态代理实现的。

1.映射文件的namespace属性值

一般情况下,一个dao接口的实现类方法使用的是同一个sql映射文件中的sql映射id。所以,MyBatis框架要求,将映射文件中<mapper/>标签的namespace属性设为dao接口的全类名,则系统会根据方法所属dao接口,自动到相应namespace的映射文件中查找相关的sql映射。

简单来说,通过接口名即可定位到映射文件mapper。

2.修改日志输出控制文件

mapper的namespace修改了,则需要将日志输出控制文件中的logger的输出对象进行修改

##define a logger
#log4j.logger.namespace_value=trace,console
log4j.logger.com.hcx.dao.IStudentDao=trace,console

3.dao接口方法名

MyBatis框架要求,接口中的方法名,与映射文件中相应的sql标签的id值相同。系统会自动根据方法名到相应的映射文件中查找同名的sql映射id。

简单来说,通过方法名就可定位到映射文件mapper中相应的sql语句。

接口:

public interface IStudentDao {

    int insertStudent(Student student); 
    void deleteStudentById(int id);
    void updateStudent(Student student);

    List<Student> selectAllStudents();
    Map<String, Object> selectAllStudentsMap();

    Student selectStudentById(int id);
    List<Student> selectStudentsByName(String name);

}

映射:

<select id="selectStudnetById" parameterType="int" resultType="com.hcx.beans.Student">
    select id,name,age,score,birthday from student where id=#{id}
</select>

4.dao对象的获取

使用时,只需要调用Sqlsession的getMapper()方法,即可获取指定接口的实现类对象。该方法的参数为指定dao接口类的class值。

session = factory.openSession();
dao = session.getMapper(IStudentDao.class);

5.删除dao实现类

由于通过调用dao接口的方法,不仅可以从sql映射文件中找到所要执行sql语句,还可通过方法参数及返回值,将sql语句的动态参数传入,将查询结果返回。所以,dao的实现工作,完全可以由MyBatis系统自动根据映射文件完成。所以,dao的实现类就不再需要了。

dao实现对象是由jdk的proxy动态代理自动生成的。

6.测试类

1.在before注解方法中获取到Sqlsession对象后,通过Sqlsession的getMapper方法创建dao接口实现类的动态代理对象。在after注解方法中关闭Sqlsession对象。

public class MyTest {

    private IStudentDao dao;
    private SqlSession session;

    @Before
    public void setUp(){
        session = MyBatisUtils.getSqlSession();
        dao = session.getMapper(IStudentDao.class);
    }

    @After
    public void tearDown(){
        if(session!=null){
            session.close();
        }
    }
}

2.添加Sqlsession的提交方法

在增删改测试方法的最后,添加Sqlsession的commit方法,完成提交。

@Test
public void test01(){
    Student student = new Student("张三",23,99.8);
    dao.insertStudent(student);
    session.commit();
}

@Test
public void test02(){
    Student student = new Student("张三",23,99.8);
    dao.insertStudentCatchId(student);
    System.out.println("student="+student);
    session.commit();
}

@Test
public void test03(){
    dao.deleteStudentById(3);   
    session.commit();
}

3.删除selectStudentMap()方法测试

MyBatis框架对于dao查询的自动实现,底层只会调用selectOne与selectList()方法。而框架选择方法的标准是测试类中用户接收返回值得对象类型。若接收类型为list,则自动选择selectList()方法;否则,自动选择selectOne()方法。

接收类型为map,所以框架选择了selectOne()方法,会报错。

7.多查询条件无法整体接收问题的解决

在实际工作中,表单中所给出的查询条件有时是无法将其封装为一个对象的,也就是说,查询方法只能携带多个参数,而不能携带将着这多个参数进行封装的一个对象。对于这个问题,有两种解决方案。

方案一:将这多个参数封装为一个map

将这多个参数封装为一个Map<String,Object>,根据Map进行查询。

1.dao接口

List<Student> selectStudentByMap(Map<String, Object> map);

2.测试类

@Test
public void test10(){
    Map<String, Object> map = new HashMap<String,Object>();
    map.put("nameCondition", "张");
    map.put("ageCondition",22);

    List<Student> students = dao.selectStudentByMap(map);
    for (Student student : students) {
        System.out.println(student);
    }
}

3.修改映射文件

<select id="selectStudentByMap" resultType="Student">
    select *from student
    where name like '%' #{nameCondition} '%'
    and age > #{ageCondition}
</select>

方案二:多个参数逐个接收

对于mapper中的SQL语句,可以通过参数索引#{index}的方式逐个接收每个参数。

1.dao接口

List<Student> selectStudentByConditions(String name,int age);

2.测试类

@Test
public void test11(){
    List<Student> students = dao.selectStudentByConditions("张", 22);
    for (Student student : students) {
        System.out.println(student);
    }
}

3.映射文件

<select id="selectStudentByconditions" resultType="Student">
    select * from student
    where name like '%' #{0} '%'
    and age > #{1}
</select>

</environments>

www.9159.com,编辑本段什么是SQLHelper

SqlHelper是一个基于.NET Framework的数据库操作组件。组件中包含数据库操作方法,目前SqlHelper有很多版本,主要以微软一开始发布的SqlHelper类,后面包含进了Enterprise Library开源包中了。还有一个主要版本是dbhelper.org开源的sqlhelper组件,优点是简洁,高性能,不仅仅支持sqlserver,同时支持sqlserver、oracle、access、Mysql数据库,也是一个开源项目,提供免费下载。

SqlHelper用于简化你重复的去写那些数据库连接(SqlConnection),SqlCommand,SqlDataReader等等。SqlHelper 封装过后通常是只需要给方法传入一些参数如数据库连接字符串,SQL参数等,就可以访问数据库了,很方便。

SqlHelper 类用于通过一组静态方法来封装数据访问功能。该类不能被继承或实例化,因此将其声明为包含专用构造函数的不可继承类。在 SqlHelper 类中实现的每种方法都提供了一组一致的重载。这提供了一种很好的使用 SqlHelper 类来执行命令的模式,同时为开发人员选择访问数据的方式提供了必要的灵活性。每种方法的重载都支持不同的方法参数,因此开发人员可以确定传递连接、事务和参数信息的方式。

转自:)

2.6.还要在主配置文件中加上对映射文件的引用

注意事项

create table test (keyId int identity,info varchar(10))
go
insert into test(info) values('a'),('b'),('ac'),('ad'),('e')
----采用在每个插入的value后面加入一个逗号
go
select * from test 
go
truncate table test 
drop table test 

     id:唯一标识名称

主要成员

2.5准备sql和mapper映射文件

编辑本段SqlHelper调用源码

编写SqlHelper调用代码:

SqlHelper支持多种数据库包括MySql、SqlServer、Oracle、Access数据库,如果的数据库是SqlServer,那么你可以使用SqlServerHelper类,如果是MySql,可以使用MySqlHelper,如果是Access,可以使用AccessHelper。如果是Oracle则可以使用OracleHelper类。

SqlHelper的书写风格很多,你可以选择自己的需求和爱好使用静态方式或对象方式。各和利弊。选择情况使用吧!

第一种,静态方式,静态方式也是目前应用最多的一种,因为其简单,所以在写一个Sql语句时,用一个方法就可以搞定。如果一个过程需要多个Sql语句执行时,得创建SqlConnection和控制他的传参,使语句复杂。或者就是每执行一个sql语句让SqlConnection创建一次,使性能受到影响。但是在只执行一个简单的查询语句时,显的更简单,所以这种方式在简单的执行逻辑面前,受到大家的喜爱!

//查询语句执行:

DataTable dt=SqlServerHelper.ReadTable("select * from table1");

//插入语句执行:

SqlServerHelper.ExecuteNonQuery("insert into [students] values(@student_name,@class)",

SqlServerHelper.CreateInputParameter("@student_name", SqlDbType.NVarChar, 100, txt_student_name_sqlserver.Text),

SqlServerHelper.CreateInputParameter("@class", SqlDbType.NVarChar, 100, txt_class_sqlserver.Text)

);

简单吧,这让项止显的代码又简单,又清晰!

第二种:面向对象式编程,其实这种语法也不复杂,只是加个using语句而己:

using (SqlServerHelper helper = new SqlServerHelper())

{

helper.Command.CommandText = "delete from [Students] where stid=@stid";

helper.AddParameter("@stid", SqlDbType. Int, student_id);

helper.Open();

helper.ExecuteNoneQuery();

helper.Command.Parameters.Clear();

helper.Command.CommandText = "select * from [Students]";return helper.ReadTable();

}

这是官方示例代码中的一部分,语法简单,在一个using语句中执行了delete删除语句和select查语句。

比如,如果你想执行事务时,可以使用:

using (SqlServerHelper helper = new SqlServerHelper())

{

helper.Command.CommandText = "delete from [Students] where stid=@stid";

helper.AddParameter("@stid", SqlDbType. Int, student_id);

helper.Open();

DbTransaction tran = helper.Connection.BeginTransaction();

helper.Command.Transaction=tran;

try

{

helper.ExecuteNoneQuery();

tran.Rollback();

}catch { tran.Rollback(); throw; }

}

     <!-- id:唯一标识一个运行环境 -->

编辑本段SqlHelper配置项

[1]在应用SqlHelper前最好使用web.config配置连接字符串,这样有利于网站的可移植性和代码的简洁。

<connectionStrings>

<!--SqlServerHelper连接字符串设定-->

<add connectionString="server=.;uid=sa;pwd=123456;database=yourdatabase" name="SqlServerHelper"/>

<!--Oracle连接字符串设定-->

<add connectionString="Data Source=orcl;User Id=system;Password=***;Integrated Security=no" name="OracleHelper"/>

<!--MySql连接字符串设定-->

<add connectionString="server=localhost;uid=root;pwd=123456;database=mysqldatabase" name="MySqlHelper"/>

</connectionStrings>

<!-- 运行环境配置 -->

编辑本段注意事项

1、如果使用SqlHelper方法调用数据库存储过程,需要获取存储过程的返回值,请使用带有SqlParameter[]参数的方法,Object[]参数的方法无法获取存储过程返回值

<!-- default:指定使用哪一个运行环境 -->

编辑本段主要成员

在 SqlHelper 类中实现的方法包括:

ExecuteNonQuery。此方法用于执行不返回任何行或值的命令。这些命令通常用于执行数据库更新,但也可用于返回存储过程的输出参数。

ExecuteReader。此方法用于返回 SqlDataReader 对象,该对象包含由某一命令返回的结果集。

ExecuteDataset。此方法返回 DataSet 对象,该对象包含由某一命令返回的结果集。

ExecuteScalar。此方法返回一个值。该值始终是该命令返回的第一行的第一列。

ExecuteXmlReader。此方法返回 FOR XML 查询的 XML 片段。

除了这些公共方法外,SqlHelper 类还包含一些专用函数,用于管理参数和准备要执行的命令。不管客户端调用什么样的方法实现,所有命令都通过 SqlCommand 对象来执行。在 SqlCommand 对象能够被执行之前,所有参数都必须添加到 Parameters 集合中,并且必须正确设置 Connection、CommandType、CommandText 和 Transaction 属性。SqlHelper 类中的专用函数主要用于提供一种一致的方式,以便向 SQL Server 数据库发出命令,而不考虑客户端应用程序调用的重载方法实现。SqlHelper 类中的专用实用程序函数包括:

AttachParameters:该函数用于将所有必要的 SqlParameter 对象连接到正在运行的 SqlCommand。

AssignParameterValues:该函数用于为 SqlParameter 对象赋值。

PrepareCommand:该函数用于对命令的属性(如连接、事务环境等)进行初始化。

ExecuteReader:此专用 ExecuteReader 实现用于通过适当的 CommandBehavior 打开 SqlDataReader 对象,以便最有效地管理与阅读器关联的连接的有效期。

     resultType:输出结果的类型(需要的是全限定名称)

目录

</select>

SqlHelper配置项

<!--namespace:名称空间,相当于java中的package,用于防止sql语句名称冲突(sql语句的隔离)  -->

SqlHelper调用源码

2.2准备配置文件sqlMapConfig.xml(mybatis的主配置文件)

编辑本段源程序(中文注释)

/// <summary>

/// 自定义访问通用类

/// </summary>

public class SqlDbHelper

{

string connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["conn"].ConnectionString;

/// <summary>

/// 构造函数

/// </summary>

public SqlDbHelper()

{

}

/// <summary>

/// ExecuteNonQuery操作,对数据库进行 增、删、改 操作((1)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <returns> </returns>

public int ExecuteNonQuery(string sql)

{

return ExecuteNonQuery(sql, CommandType.Text, null);

}

/// <summary>

/// ExecuteNonQuery操作,对数据库进行 增、删、改 操作(2)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <param name="commandType">要执行的查询类型(存储过程、SQL文本) </param>

/// <returns> </returns>

public int ExecuteNonQuery(string sql, CommandType commandType)

{

return ExecuteNonQuery(sql, commandType, null);

}

/// <summary>

/// ExecuteNonQuery操作,对数据库进行 增、删、改 操作(3)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <param name="commandType">要执行的查询类型(存储过程、SQL文本) </param>

/// <param name="parameters">参数数组 </param>

/// <returns> </returns>

public int ExecuteNonQuery(string sql, CommandType commandType, SqlParameter[] parameters)

{

int count = 0;

using (SqlConnection connection = new SqlConnection(connectionString))

{

using (SqlCommand command = new SqlCommand(sql, connection))

{

command.CommandType = commandType;

if (parameters != null)

{

foreach (SqlParameter parameter in parameters)

{

command.Parameters.Add(parameter);

}

}

connection.Open();

count = command.ExecuteNonQuery();

}

}

return count;

}

/// <summary>

/// SqlDataAdapter的Fill方法执行一个查询,并返回一个DataSet类型结果(1)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <returns> </returns>

public DataSet ExecuteDataSet(string sql)

{

return ExecuteDataSet(sql, CommandType.Text, null);

}

/// <summary>

/// SqlDataAdapter的Fill方法执行一个查询,并返回一个DataSet类型结果(2)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <param name="commandType">要执行的查询类型(存储过程、SQL文本) </param>

/// <returns> </returns>

public DataSet ExecuteDataSet(string sql, CommandType commandType)

{

return ExecuteDataSet(sql, commandType, null);

}

/// <summary>

/// SqlDataAdapter的Fill方法执行一个查询,并返回一个DataSet类型结果(3)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <param name="commandType">要执行的查询类型(存储过程、SQL文本) </param>

/// <param name="parameters">参数数组 </param>

/// <returns> </returns>

public DataSet ExecuteDataSet(string sql, CommandType commandType, SqlParameter[] parameters)

{

DataSet ds = new DataSet();

using (SqlConnection connection = new SqlConnection(connectionString))

{

using (SqlCommand command = new SqlCommand(sql, connection))

{

command.CommandType = commandType;

if (parameters != null)

{

foreach (SqlParameter parameter in parameters)

{

command.Parameters.Add(parameter);

}

}

SqlDataAdapter adapter = new SqlDataAdapter(command);

adapter.Fill(ds);

}

}

return ds;

}

/// <summary>

/// SqlDataAdapter的Fill方法执行一个查询,并返回一个DataTable类型结果(1)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <returns> </returns>

public DataTable ExecuteDataTable(string sql)

{

return ExecuteDataTable(sql, CommandType.Text, null);

}

/// <summary>

/// SqlDataAdapter的Fill方法执行一个查询,并返回一个DataTable类型结果(2)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <param name="commandType">要执行的查询类型(存储过程、SQL文本) </param>

/// <returns> </returns>

public DataTable ExecuteDataTable(string sql, CommandType commandType)

{

return ExecuteDataTable(sql, commandType, null);

}

/// <summary>

/// SqlDataAdapter的Fill方法执行一个查询,并返回一个DataTable类型结果(3)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <param name="commandType">要执行的查询类型(存储过程、SQL文本) </param>

/// <param name="parameters">参数数组 </param>

/// <returns> </returns>

public DataTable ExecuteDataTable(string sql, CommandType commandType, SqlParameter[] parameters)

{

DataTable data = new DataTable();

using (SqlConnection connection = new SqlConnection(connectionString))

{

using (SqlCommand command = new SqlCommand(sql, connection))

{

command.CommandType = commandType;

if (parameters != null)

{

foreach (SqlParameter parameter in parameters)

{

command.Parameters.Add(parameter);

}

}

SqlDataAdapter adapter = new SqlDataAdapter(command);

adapter.Fill(data);

}

}

return data;

}

/// <summary>

/// ExecuteReader执行一查询,返回一SqlDataReader对象实例(1)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <returns> </returns>

public SqlDataReader ExecuteReader(string sql)

{

return ExecuteReader(sql, CommandType.Text, null);

}

/// <summary>

/// ExecuteReader执行一查询,返回一SqlDataReader对象实例(2)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <param name="commandType">要执行的查询类型(存储过程、SQL文本) </param>

/// <returns> </returns>

public SqlDataReader ExecuteReader(string sql, CommandType commandType)

{

return ExecuteReader(sql, commandType, null);

}

/// <summary>

/// ExecuteReader执行一查询,返回一SqlDataReader对象实例(3)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <param name="commandType">要执行的查询类型(存储过程、SQL文本) </param>

/// <param name="parameters">参数数组 </param>

/// <returns> </returns>

public SqlDataReader ExecuteReader(string sql, CommandType commandType, SqlParameter[] parameters)

{

SqlConnection connection = new SqlConnection(connectionString);

SqlCommand command = new SqlCommand(sql, connection);

command.CommandType = commandType;

if (parameters != null)

{

foreach (SqlParameter parameter in parameters)

{

command.Parameters.Add(parameter);

}

}

connection.Open();

return command.ExecuteReader(CommandBehavior.CloseConnection);

}

/// <summary>

/// ExecuteScalar执行一查询,返回查询结果的第一行第一列(1)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <returns> </returns>

public Object ExecuteScalar(string sql)

{

return ExecuteScalar(sql, CommandType.Text, null);

}

/// <summary>

/// ExecuteScalar执行一查询,返回查询结果的第一行第一列(2)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <param name="commandType">要执行的查询类型(存储过程、SQL文本) </param>

/// <returns> </returns>

public Object ExecuteScalar(string sql, CommandType commandType)

{

return ExecuteScalar(sql, commandType, null);

}

/// <summary>

/// ExecuteScalar执行一查询,返回查询结果的第一行第一列(3)

/// </summary>

/// <param name="sql">要执行的SQL语句 </param>

/// <param name="commandType">要执行的查询类型(存储过程、SQL文本) </param>

/// <returns> </returns>

public Object ExecuteScalar(string sql, CommandType commandType, SqlParameter[] parameters)

{

object result = null;

using (SqlConnection connection = new SqlConnection(connectionString))

{

using (SqlCommand command = new SqlCommand(sql, connection))

{

command.CommandType = commandType;

if (parameters != null)

{

foreach (SqlParameter parameter in parameters)

{

command.Parameters.Add(parameter);

}

}

connection.Open();

result = command.ExecuteScalar();

}

}

return result;

}

/// <summary>

/// 返回当前连接的数据库中所有由用户创建的数据库

/// </summary>

/// <returns> </returns>

public DataTable GetTables()

{

DataTable data = null;

using (SqlConnection connection = new SqlConnection(connectionString))

{

connection.Open();

data = connection.GetSchema("Tables");

}

return data;

}

}

一. 简介

什么是SQLHelper

<mappers>

     <groupId>org.mybatis</groupId>

2.3.准备log4j.properties

www.9159.com 5

     </environment>

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

     #{id}:占位符,相当于jdbc中的? -->

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

<!DOCTYPE configuration

     <!-- 加载User.xml文件,说明: 1.resource:指定配置文件的位置 -->

     parameterType:输入参数的类型

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

<!--mybatis针对每一种sql语句:新增/修改/删除/查询,

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

<!-- 根据用户Id查询用户,说明:

<mapper namespace="test">

2.4.编写pojo实体类

</mapper>

<!DOCTYPE mapper

提供了对应的标签:insert/update/delete/select来放置-->

<configuration>

";

</mappers>

2.7.mybatis的运行原理

";

<?xml version="1.0" encoding="UTF-8" ?>

         <dataSource type="POOLED">

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

<select id="queryUserById" parameterType="int" resultType="com.code.po.User">

<environments default="development">

             <property name="url" value="jdbc:mysql://127.0.0.1:3306/79_mybatis" />

         <transactionManager type="JDBC" />

     <artifactId>mybatis</artifactId>

         <!-- 数据源配置 -->

     select * from `user` where id=#{id}

<dependency>

</dependency>

2.5.2.mapper映射文件就是用户配置的Java对象与sql语句的对应关系

2.1.  配置pom.xml,加入mybatis依赖

<!-- 加载mapper映射文件 -->

</configuration>

<?xml version="1.0" encoding="UTF-8" ?>

mybatis早期版本叫做Ibatis,目前代码托管在github,是一个对jdbc进行封装的持久层框架。mybatis通过xml或注解进行配置,将“java对象”与“sql语句中的参数”自动映射生成最终执行的sql语句,并将sql语句执行结果自动映射成java对象,返回给业务层(service)应用。

2.5.1.sql语句对应增删改查操作。

     select标签:用于放置查询sql语句

     <version>3.4.5</version>

二.使用流程

与数据库的字段对应

     <environment id="development">

        <!-- 配置事务 -->

         </dataSource>

本文由9159.com发布于www.9159.com,转载请注明出处:源程序(中文注释),自动映射生成最终执行的

关键词: