Day62 Mybatis基于SqlSession对象的查询

最新推荐文章于 2023-07-31 15:48:32 发布

神一样的我

最新推荐文章于 2023-07-31 15:48:32 发布

阅读量436

点赞数

分类专栏： Mybatis

本文链接：https://blog.csdn.net/qq_21953671/article/details/79732865

版权

Mybatis 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Mybatis框架配置文件的进一步补充

Mybatis学习(第二天)：
    eclipse配置本地dtd文件：
        在根盘符下创建dtd文件夹，例如：D盘下
        在mybatis的源码中搜索DTD文件，将其复制到dtd文件夹中
        在eclipse的window下preferces中选择-->xmlcatalog-->add--->location选择dtd文件夹中的dtd文件路径，key的值为dtd引入的网址
        例如：
            http://mybatis.org/dtd/mybatis-3-config.dtd
    mybatis常见错误：
        第一：Mapped Statements collection does not contain value for com.bjsxt.mapper.FlowerMapper.selF2
            问题：因为mybatis.xml中的mapper路径配置不正确，获取sqlPath书写不正确造成的
        第二：Unknown DataSource property: user
            问题：数据库源配置参数名写错了
    mybatis开启自定义别名：
        在mybatis.xml中使用typeAliases标签开启自定义别名
        <typeAliases>
        <!-- 给指定的实体类添加指定的别名 -->
        <!-- <typeAlias type="com.bjsxt.pojo.Flower" alias="f"/> -->
        <!-- 包中的类名即别名，不区分大小写 -->
        <package name="com.bjsxt.pojo"/>
        </typeAliases>
    mybatis.xml配置文件开启log4j支持
        只需要在src下创建log4j.properties文件，即可开启。mybatis的log4j默认是开启状态
        <!--开启mybatis的日志支持  -->
        <settings>
            <setting name="logImpl" value="SLF4J"/>
        </settings>
    mybatis集成了数据库连接池：
        单例设计模式：
            问题：
                我们现有获取了类对象的方式是通过new关键字进行创建，每new一次，就会创建
            一个新的对象，数据也就不同了。但是，在不同的处理代码中，我们往往需要获取到同一个对象，这样才能获取到相同的数据，。
            解决：
                使用单例设计模式
            使用：
                饿汉式
                懒汉式
        数据库连接池的原理：
            数据库连接池中长存固定个数的数据库连接对象
                我们不在直接的进行数据库连接对象的创建和关闭，通过数据库连接池进行获取数据库连接对象
        数据库连接池的优点：
            避免了数据库的频繁的打开和关闭
        数据库连接池的使用：
            导入jar包
            创建并配置数据库连接池的配置文件
            使用数据库连接池获取数据库连接对象
                第一种方式：
                    使用工具类进行数据库连接池的创建和使用，注意：连接池是在第一次访问的时候被创建的。
                第二种方式:
                     服务器启动数据库连接池即创建完毕
                    配置web.xml
                    获取数据库连接池conn对象即可

基于SqlSession对象的数据库操作：

mybatis完成单表无参数查询  
    mybatis完成单表单参数的增删改查   
        单参数：
            指的是原生的JDBC数据操作方法的参数为一个参数，不是SQL语句的参数为一个参数
        原因：
            因为SqlSession对象封装增删改查方法只接受一个数据库操作相关的实参。
        mapper配置文件中的标签属性：
            parameterType:声明的单参数的实参类型
        查询：
            参数为基本类型
                占位符使用#{0}
            <!--参数为基本变量类型  -->
                <select id="selById" parameterType="string"  resultType="flower">
                    select * from flower where name=#{0}
                </select>

                //单表单参数查询---参数为基本类型
                    Flower f=ss.selectOne("com.bjsxt.mapper.FlowerMapper.selById","百日草");
                    System.out.println(f);

            参数为引用类型
                占位符使用#{键名}
                <!--参数为引用类型  map集合 占位符中书写键名 -->
            <select id="selByObj" parameterType="map" resultType="flower">
                select * from flower where production like #{production} and price> #{price}
            </select>

            Map<String,String> map=new HashMap<String,String>();
            map.put("production", "%商%");
            map.put("price", "3.5");
            List<Flower> lf2=ss.selectList("com.bjsxt.mapper.FlowerMapper.selByObj", map);
            System.out.println(lf2);


        <!--参数为引用类型 实体类对象 占位符中书写属性名 -->
            <select id="selByPojo" parameterType="flower" resultType="flower">
                select * from flower where production=#{production}
            </select>
            Flower f2=new Flower(0, "", 4.3, "巴西");
            Flower f3=ss.selectOne("com.bjsxt.mapper.FlowerMapper.selByPojo", f2);
            System.out.println(f3);

            查询方法使用
                selectOne(String sqlPath,Object obj)
                selectList(String sqlPath,Object obj)
        注意：
            增加删除修改需要手动进行数据的提交：
                ss.commit();//提交数据
        增加：
            <!--添加数据  -->
            <insert id="insF" parameterType="flower">
                insert into flower values(default,#{name},#{price},#{production});
            </insert>
        //添加
            Flower fs=new Flower(0,"花",5.55,"商丘");
            int i=ss.insert("com.bjsxt.mapper.FlowerMapper.insF",fs );      
            System.out.println(i);
        修改：
            <!--修改数据  -->
            <update id="upF" parameterType="map">
                update flower set name=#{name} where id=#{id}
            </update>
        Map<String,String> map2=new HashMap<String,String>();   
            map2.put("name", "花样少年");
            map2.put("id", "8");
            int i2=ss.update("com.bjsxt.mapper.FlowerMapper.upF", map2);
            System.out.println(i2);
        删除：
            <!--删除数据  -->
            <delete id="delF" parameterType="string">
                delete from flower where name like #{0}
            </delete>

        int i3=ss.delete("com.bjsxt.mapper.FlowerMapper.delF", "花%");
        System.out.println(i3);

        注意：
            在mybatis中使用#{0}或者#{键名}进行sql语句的参数占位，底层调用的是preparedStatement对象完成的数据库操作。
            ${}在mybatis中代表的是Statement对象，底层SQL语句使用的是字符串拼接方式.

其他知识点:

ORM：对象关系映射（英语：(Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换[1]  。从效果上说，它其实是创建了一个可在编程语言里使用的--“虚拟对象数据库”。
Mybatis是半自动化的ORM框架
注意：xml的参数的配置顺序问题：
(properties?, settings?, typeAliases?, typeHandlers?, objectFactory?, 
 objectWrapperFactory?, plugins?, environments?, databaseIdProvider?, mappers?)

log4J的配置文件：
在myeclipse或者myeclipse的文件里搜索log4j.  即可找到，然后复制到项目中src文件夹下修改参数即可。
# Set root category priority to INFO and its only appender to CONSOLE.
log4j.rootCategory=INFO
#log4j.rootCategory=INFO, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.com.bjsxt.mapper=debug, CONSOLE      //设置要打印日志的位置

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=- %m%n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=C:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=- %m%n

数据库连接池：
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。

单例模式：单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例

记住设置transactionManager  为JDBC时，是指使用原生的JDBC，提交事务是手动的，所以在增删改的时候要用sqlSession对象手动提交事务。


注解和sevlet3.0：
https://blog.csdn.net/estelle_belle/article/details/51751828
10 /**
11  * 注解WebServlet用来描述一个Servlet
12  * 属性name描述Servlet的名字,可选
13  * 属性urlPatterns定义访问的URL,或者使用属性value定义访问的URL.(定义访问的URL是必选属性)
14  */
15 @WebServlet(name="Servlet3Demo",urlPatterns="/Servlet3Demo")

parameterType的类型为别名
mybatis的内置别名：
这是一些为常见的 Java 类型内建的相应的类型别名。它们都是大小写不敏感的，需要注意的是由基本类型名称重复导致的特殊处理。
别名  映射的类型
_byte   byte
_long   long
_short  short
_int    int
_integer    int
_double     double
_float  float
_boolean    boolean
string  String
byte    Byte
long    Long
short   Short
int     Integer
integer     Integer
double  Double
float   Float
boolean     Boolean
date    Date
decimal     BigDecimal
bigdecimal  BigDecimal
object  Object
map     Map
hashmap     HashMap
list    List
arraylist   ArrayList
collection  Collection
iterator    Iterator

小案例：

需求：

实现：简单的转账功能

这里写图片描述

思路分析：

Mybatis第三天:
    作业处理：
        需求：实现银行转账功能
        需求分析：
            功能分析：
                银行转账：
                         -------------------------------------------------------------------------(前端页面--VIEW层)
                    点击转账，将转账信息发送给对应的Servlet(前端页面--VIEW层)
                    数据：
                        转账账户
                        密码
                        金额
                        收款账号
                        收款人姓名
                        操作符
                    提交方式：
                        使用form表单
                -------------------------------------------------------------------(Servlet层---Controller层)
                tomcat服务器接受到请求，调用指定的servlet进行处理
                设置请求编码格式
                设置响应编码格式
                获取请求信息
                处理请求信息
                    调用业务层对象
                    将转账信息流转给业务层进行处理 
                    返回处理结果
                响应处理结果
                    重定向
                        根据业务层处理的结果进行页面响应
                    ----------------------------------------------------------------------业务层
                     根据转账账户和密码校验账户信息
                        正确：校验转账账户的余额
                            正确:校验收款人账号的姓名
                                正确：开始转账
                                    转账成功
                                        提交数据
                                    转账失败
                                        回滚数据
                                不正确：直接返回
                            不正确：直接返回
                      不正确：直接返回
                    ----------------------------------------------------------------------mapper层
                        根据账号和密码查询账户信息
                        根据账号和姓名查询账户信息
                        转账语句
                转账日志记录:
                    在业务层中，当转账成功时，执行一个插入语句即可
                    数据：
                        转账账号
                        入账账号
                        金额
            数据库设计：
                账户信息表：
                    账户ID
                    账户姓名
                    账户密码
                    金额
                日志记录表
                    转账ID            
                    入账ID                
                    转账金额
            代码设计:
                 使用myBatis技术进行实现(Servlet+jsp+mybatis)
                 搭建mybatis运行环境          
    搭建mybatis运行环境
        导入jar包
        配置mybatis.xml
        配置mapper.xml
        基于sqlsession的单表增删改查

mybatis框架构建：
这里写图片描述

编码过程中需要导入mybatis相关的Jar包，何Gson的jar包，数据库使用MySQL，表中字段在实体类里。
com.bjsxt.mapper：
AccountMapper.xml：

<?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.bjsxt.mapper.AccountMapper">
    <!-- 根据账号和密码查询账户信息 -->
    <select id="selAcOut" parameterType="account" resultType="account">
        select * from account where aid=#{aid} and apwd=#{apwd}
    </select>
    <!--根据账号和用户名查询账户信息  -->
    <select id="selAcIn" parameterType="account" resultType="account">
        select  * from account where aid=#{aid} and aname=#{aname}
    </select>
    <!--转账  -->
    <update id="upMoney" parameterType="account">
        update account set money=money+#{money} where aid=#{aid}
    </update>
 </mapper>

LogMapper.xml：

<?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.bjsxt.mapper.LogMapper">
    <!--插入转账日志  -->
    <insert id="insLog" parameterType="map">
        insert into Log values(#{outid},#{inid},#{money})
    </insert>
    <!--查询日志信息  -->
    <select id="selLog" parameterType="pageInfo" resultType="log">
        select * from log limit #{pageStart},#{pageSize}
    </select>
  </mapper>

com.bjsxt.pojo：
Account.java：

package com.bjsxt.pojo;

public class Account {
    private int aid;
    private String aname;
    private String apwd;
    private double money;
    public int getAid() {
        return aid;
    }
    public void setAid(int aid) {
        this.aid = aid;
    }
    public String getAname() {
        return aname;
    }
    public void setAname(String aname) {
        this.aname = aname;
    }
    public String getApwd() {
        return apwd;
    }
    public void setApwd(String apwd) {
        this.apwd = apwd;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "Account [aid=" + aid + ", aname=" + aname + ", apwd=" + apwd + ", money=" + money + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + aid;
        result = prime * result + ((aname == null) ? 0 : aname.hashCode());
        result = prime * result + ((apwd == null) ? 0 : apwd.hashCode());
        long temp;
        temp = Double.doubleToLongBits(money);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Account other = (Account) obj;
        if (aid != other.aid)
            return false;
        if (aname == null) {
            if (other.aname != null)
                return false;
        } else if (!aname.equals(other.aname))
            return false;
        if (apwd == null) {
            if (other.apwd != null)
                return false;
        } else if (!apwd.equals(other.apwd))
            return false;
        if (Double.doubleToLongBits(money) != Double.doubleToLongBits(other.money))
            return false;
        return true;
    }
    public Account() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Account(int aid, String aname, String apwd, double money) {
        super();
        this.aid = aid;
        this.aname = aname;
        this.apwd = apwd;
        this.money = money;
    }




}

Log.java：

package com.bjsxt.pojo;

public class Log {
    private int outid;
    private int inid;
    private double money;
    public int getOutid() {
        return outid;
    }
    public void setOutid(int outid) {
        this.outid = outid;
    }
    public int getInid() {
        return inid;
    }
    public void setInid(int inid) {
        this.inid = inid;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "Log [outid=" + outid + ", inid=" + inid + ", money=" + money + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + inid;
        long temp;
        temp = Double.doubleToLongBits(money);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        result = prime * result + outid;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Log other = (Log) obj;
        if (inid != other.inid)
            return false;
        if (Double.doubleToLongBits(money) != Double.doubleToLongBits(other.money))
            return false;
        if (outid != other.outid)
            return false;
        return true;
    }
    public Log() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Log(int outid, int inid, double money) {
        super();
        this.outid = outid;
        this.inid = inid;
        this.money = money;
    }



}

PageInfo.java：

package com.bjsxt.pojo;

import java.util.List;

public class PageInfo {
    private int pageNum;
    private int pageStart;
    private int pageSize;
    private List<Log> ll;
    public int getPageNum() {
        return pageNum;
    }
    public void setPageNum(int pageNum) {
        this.pageNum = pageNum;
    }
    public int getPageStart() {
        return pageStart;
    }
    public void setPageStart(int pageStart) {
        this.pageStart = pageStart;
    }
    public int getPageSize() {
        return pageSize;
    }
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }
    public List<Log> getLl() {
        return ll;
    }
    public void setLl(List<Log> ll) {
        this.ll = ll;
    }
    @Override
    public String toString() {
        return "PageInfo [pageNum=" + pageNum + ", pageStart=" + pageStart + ", pageSize=" + pageSize + ", ll=" + ll
                + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((ll == null) ? 0 : ll.hashCode());
        result = prime * result + pageNum;
        result = prime * result + pageSize;
        result = prime * result + pageStart;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        PageInfo other = (PageInfo) obj;
        if (ll == null) {
            if (other.ll != null)
                return false;
        } else if (!ll.equals(other.ll))
            return false;
        if (pageNum != other.pageNum)
            return false;
        if (pageSize != other.pageSize)
            return false;
        if (pageStart != other.pageStart)
            return false;
        return true;
    }
    public PageInfo() {
        super();
        // TODO Auto-generated constructor stub
    }
    public PageInfo(int pageNum, int pageStart, int pageSize, List<Log> ll) {
        super();
        this.pageNum = pageNum;
        this.pageStart = pageStart;
        this.pageSize = pageSize;
        this.ll = ll;
    }



}

com.bjsxt.service：
AccountService.java：

package com.bjsxt.service;

import java.io.IOException;

import com.bjsxt.pojo.Account;

public interface AccountService {

    /**
     * 转账账户ID和密码不匹配
     */
    int ACCOUNT_OUT_ID_PWD_NOTMACTH=1;
    /**
     * 账户余额不足
     */
    int ACCOUNT_OUT_MONEY_NOT_ENOUGH=3;
    /**
     * 入账账户ID和用户名不匹配
     */
    int ACCOUNT_IN_ID_NAME_NOTMATCH=4;
    /**
     * 转账成功
     */
    int ACCOUNT_SUCCESS=2;
    /**
     * 转账失败
     */
    int ACCOUNT_FAILED=-1;
    /**
     * 实现银行转账功能
     * @param acout
     * @param acin
     * @return
     */
    int transferAccount(Account acout,Account acin)throws IOException;
}

LogService.java：

package com.bjsxt.service;

import java.io.IOException;

import com.bjsxt.pojo.PageInfo;

public interface LogService {

    PageInfo getLogInfoService(int pageNum,int pageSize)throws IOException;
}

com.bjsxt.serviceImpl：
AccountServiceImpl.java：

package com.bjsxt.serviceImpl;

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

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.apache.log4j.Logger;

import com.bjsxt.pojo.Account;
import com.bjsxt.service.AccountService;

public class AccountServiceImpl implements AccountService{
    //声明Logger日志对象
    private Logger logger=Logger.getLogger(AccountServiceImpl.class);
    //银行转账
    @Override
    public int transferAccount(Account acout, Account acin) throws IOException {
        //获取SqlSession对象
            InputStream is = Resources.getResourceAsStream("mybatis.xml");
            SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
            SqlSession ss=factory.openSession();
        //校验转账账户信息
            Account acout2=ss.selectOne("com.bjsxt.mapper.AccountMapper.selAcOut",acout);
            if(acout2!=null){
                //校验金额
                    if(acout.getMoney()<=acout2.getMoney()){
                        //校验入账账户信息
                            Account acin2=ss.selectOne("com.bjsxt.mapper.AccountMapper.selAcIn",acin);
                            if(acin2!=null){
                                //开始转账
                                    //转账账户转出
                                        acout.setMoney(-acout.getMoney());
                                        int i=ss.update("com.bjsxt.mapper.AccountMapper.upMoney", acout);
                                    //入账账户转入
                                        i+=ss.update("com.bjsxt.mapper.AccountMapper.upMoney", acin);
                                    //校验
                                        if(i==2){
                                            //将转账日志插入到数据库中
                                            Map<String,Object> map=new HashMap<String,Object>();
                                            map.put("outid", acout.getAid());
                                            map.put("inid", acin.getAid());
                                            map.put("money", acin.getMoney());
                                            ss.insert("com.bjsxt.mapper.LogMapper.insLog", map);
                                            //提交
                                            ss.commit();
                                            //打印log日志
                                            logger.debug(acout.getAid()+"在"+new Date().toLocaleString()+"给"+acin.getAid()+"转了"+acin.getMoney()+"元钱");
                                            return ACCOUNT_SUCCESS;
                                        }else{
                                            ss.rollback();
                                            return ACCOUNT_FAILED;
                                        }
                            }else{
                                return ACCOUNT_IN_ID_NAME_NOTMATCH; 
                            }

                    }else{
                        return ACCOUNT_OUT_MONEY_NOT_ENOUGH;
                    }

            }else{
                return ACCOUNT_OUT_ID_PWD_NOTMACTH;
            }
    }

}

LogServiceImpl.java：

package com.bjsxt.serviceImpl;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

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 com.bjsxt.pojo.Log;
import com.bjsxt.pojo.PageInfo;
import com.bjsxt.service.LogService;

public class LogServiceImpl implements LogService{

    @Override
    public PageInfo getLogInfoService(int pageNum, int pageSize) throws IOException {
        //创建SqlSession对象
            InputStream is = Resources.getResourceAsStream("mybatis.xml");
            SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
            SqlSession ss=factory.openSession();
        //创建pageStart
        int pageStart=pageNum*pageSize-pageSize;
        //将数据存储到PageInfo中
        PageInfo p=new PageInfo();
        p.setPageStart(pageStart);
        p.setPageNum(pageNum);
        p.setPageSize(pageSize);
        List<Log> ll=ss.selectList("com.bjsxt.mapper.LogMapper.selLog",p);
        p.setLl(ll);
        return p;
    }

}

com.bjsxt.servlet：
AccountServlet.java：

package com.bjsxt.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.bjsxt.pojo.Account;
import com.bjsxt.service.AccountService;
import com.bjsxt.serviceImpl.AccountServiceImpl;

/**
 * Servlet implementation class AccountServlet
 */
@WebServlet("/as")
public class AccountServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //设置请求编码格式
        req.setCharacterEncoding("utf-8");
        //设置响应编码格式
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");
        //获取请求信息
            int  outid=Integer.parseInt(req.getParameter("outid"));
            String outpwd=req.getParameter("outpwd");
            double money=Double.parseDouble(req.getParameter("money"));
            int inid=Integer.parseInt(req.getParameter("inid"));
            String inname=req.getParameter("inname");
        //处理请求信息
            //将请求数据存储到实体类对象中
            Account acout=new Account();
                acout.setAid(outid);
                acout.setApwd(outpwd);
                acout.setMoney(money);
            Account acin=new Account();
                acin.setAid(inid);
                acin.setAname(inname);
                acin.setMoney(money);
            //调用业务层实现转账
                AccountService as=new AccountServiceImpl();
                int i=as.transferAccount(acout, acin);
                //创建Session
                req.getSession().setAttribute("i", i);
                if(i==as.ACCOUNT_SUCCESS){
                    //响应处理结果
                        //使用重定向
                        resp.sendRedirect("log.jsp");
                }else{  
                    //使用重定向
                    resp.sendRedirect("error.jsp");
                }

    }

}

LogServlet.java：

package com.bjsxt.servlet;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.bjsxt.pojo.PageInfo;
import com.bjsxt.service.LogService;
import com.bjsxt.serviceImpl.LogServiceImpl;
import com.google.gson.Gson;

/**
 * Servlet implementation class LogServlet
 */
@WebServlet("/log")
public class LogServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //设置请求编码格式
        req.setCharacterEncoding("utf-8");
        //设置响应编码格式
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");
        //获取请求信息
        int pageNum=req.getParameter("pageNum")!=null?Integer.parseInt(req.getParameter("pageNum")):1;
        int pageSize=req.getParameter("pageSize")!=null?Integer.parseInt(req.getParameter("pageSize")):2;
        //处理请求信息
        LogService ls=new LogServiceImpl();
        PageInfo p=ls.getLogInfoService(pageNum, pageSize);
        //响应处理结果
        resp.getWriter().write(new Gson().toJson(p));
    }

}

log4j.properties：


log4j.rootCategory=info



log4j.logger.com.bjsxt.mapper=debug, CONSOLE
log4j.logger.com.bjsxt.serviceImpl=debug, CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=- %c-%d-%m%n


log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=D:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=- %c-%d-%m%n

mybatis.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>
    <!-- 开启别名支持 -->
    <typeAliases>
        <package name="com.bjsxt.pojo"/>
    </typeAliases>
    <!--创建数据库环境  -->
    <environments default="mysql">
        <!--配置数据库环境  -->
        <environment id="mysql">
            <!--配置事务  -->
                <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源  -->
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                    <property name="username" value="root"/>
                    <property name="password" value="1234"/>
                </dataSource>
        </environment>
    </environments> 
    <!-- 配置mapper -->
        <mappers>
            <mapper resource="com/bjsxt/mapper/AccountMapper.xml"/>
            <mapper resource="com/bjsxt/mapper/LogMapper.xml"/>
        </mappers>
  </configuration>

transfer.jsp：

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
    <form action="as" method="post">
        转账账户ID：<input type="text" name="outid" value=""/><br />
        密码:<input type="password" name="outpwd" value="" /><br />
        金额:<input type="text" name="money" value=""/><br />
        入账账户ID：<input type="text" name="inid" value=""/><br />
        姓名:<input type="text" name="inname" value=""/><br />
        <input type="submit" value="提交" /><br />
    </form>
</body>
</html>

log.jsp：

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
<!--引入jQuery文件  -->
<script type="text/javascript" src="js/j.js"></script>
<!--声明js代码域  -->
<script type="text/javascript">
    $(function(){
        //声明变量记录当前页码数据
        var page;
        //上一页功能
        $("#up").click(function(){
            getData(page-1,2);
        })
        //下一页功能
        $("#down").click(function(){
            getData(page+1,2);
        })

        getData(1,2);
        function getData(pageNum,pageSize){
            $.get("log",{pageNum:pageNum,pageSize:pageSize},function(data){
                //使用eval转换
                eval("var p="+data);
                page=p.pageNum;
                //获取表格对象
                var ta=$("#ta");
                //清空原有内容
                ta.empty();
                //增加表头
                ta.append("<tr>"+
                        "<td>转账账户</td>"+
                        "<td>入账账户</td>"+
                        "<td>金额</td>"+
                        "</tr>");
                //遍历数据填充到表格
                for(var i=0;i<p.ll.length;i++){
                    ta.append("<tr>"+
                            "<td>"+p.ll[i].outid+"</td>"+
                            "<td>"+p.ll[i].inid+"</td>"+
                            "<td>"+p.ll[i].money+"</td>"+
                            "</tr>");
                }

            })
        }
    })


</script>
</head>
<body>
    <table id="ta">

    </table>
    <a id="up" href="javascript:void(0)">上一页</a>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
    <a id="down" href="javascript:void(0)">下一页</a>
</body>
</html>

error.jsp：

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
    转账失败，错误代码为:${i}
</body>
</html>

导入js1.9版本

源码地址：
链接：https://pan.baidu.com/s/1M_PMsShIv2EmsnkKUX18Gg 密码：bsm8

小结

mybatis配置文件的进一步补充
数据库连接池的概念
单例模式
基于SqlSession对象的简单操作（增删改查）
小案例

神一样的我

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day62 Mybatis基于SqlSession对象的查询

Mybatis框架配置文件的进一步补充Mybatis学习(第二天)： eclipse配置本地dtd文件：在根盘符下创建dtd文件夹，例如：D盘下在mybatis的源码中搜索DTD文件，将其复制到dtd文件夹中在eclipse的window下preferces中选择--&amp;gt;xmlcatalog--&amp;gt;add---&amp;gt;l...
复制链接

扫一扫

专栏目录