明明的demo日常
明明的demo日常

myBatis简单全面

目录

myBatis入门程序步骤

整体代码

myBatis日志集成框架logback

 使用myBatis完成CRUD（增删改查）

什么是CRUD

MyBatis核⼼配置⽂件详解

SqlSessionFactoryBuilder、SqlSessionFactory对象作用域

properties 标签的配置

在WEB中应用MyBatis（用MVC架构）

是用Javassist生成DaoImpl

mybatis小技巧

#{}和${}区别

小技巧之typeAliases 

idea配置文件模版 

 插入数据时获取自动生成的主键

mybatis参数处理

单个简单参数类型

Map参数类型 处理

实体类参数

多个参数传递分两种情况

查询专题之返回

动态SQL（重要）

if标签

where标签 

trim标签 

 set标签

choose when otherwise 标签 

批量删除 

 批量插入

 mybatis高级映射及延迟加载

 多对一

 级联属性映射 

association实现

分布查询（常用）

 一对多

第一种collection

 分步查询

 mybatis缓存

mybatis逆向工程

分页插件PageHelper

mybatis注解

了解myBatis

myBatis本质是对JDBC的封装，通过MyBatis完成CRUD(CRUD是指在做计算处理时的增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词的首字母简写)属于持久层框架

myBatis一种思想（掌握）：ORM（对象关系映射）

        O（object）：JVM中的java对象

        R（Relational）：关系型数据库

        M（Mapping）：映射

看图：

        表名对应java中的一个类

        字段对应java属性

        把一条数据转换成java对象或将Java对象转换成一条数据这就叫做映射        

myBatis简单全面_第1张图片

 myBatis是半自动化的ORM，因为SQL语句需要程序员自己编写

 myBatis可以干嘛：将Java对象和数据库表中的数据进行相互转换

myBatis入门程序步骤

一、创建一个maven项目，在resources目录中防止资源文件，它相当于类的根路径。

二、开发步骤

第一步：规定打包方式为jar       

  com.jmm
  mybatis-001-introduction
  1.0.0
  jar

第二步：引入依赖

        -myBatis依赖和mysql依赖

 
      org.mybatis
      mybatis
      3.5.10
    

    
      mysql
      mysql-connector-java
      8.0.30

第三步：编写mybatis核心配置文件：mybatis-config.xml

        mybatis-config.xml：这个名字不是固定的但是普遍使用该名字，一般情况下将它放在根路径下。该代码段在下载的mybatis压缩文件中有一个PDF(或者搜索：mybatis中文文档），里面有相应的代码，虽然现在不理解代码意思，没关系先让代码跑起来，下边会解释。里边的driver-URL-username-password换成自己的数据库信息

myBatis简单全面_第2张图片

第四步：编写XxxxMapper.xml文件

        这个配置文件是用来编写SQL语句的，命名规则：一般情况你写的是t_student表，起名StudentMapper.xml，我这里是t_car的所以这里起名CarMapper.xml.

        该文件的位置是随意的，我这里将他放在了根目录下，也就是resources下

第五步：在mybatis-config.xml文件中指定XxxxMapper.xml文件的路径：

注意：resource属性会自动葱类的根路径下开始查找资源

第六步：编写mybatis程序（使用mybatis的类库，编写陈旭连接数据库做增删改查）

在mybatis中，负责执行SQL语句的对象叫：SqlSession

该对象是专门用来执行SQL语句的，是一个Java程序和数据库之间的一次对话

但想要获取该对象，需要先获取SqlSessionFactory对象，通过SqlSessionFactor有工厂来生产该对象，那怎样获取这个工厂呢？

        需要通过SqlSessionFactoryBuilder对象，通过他的build的方法获取这个工厂

整体顺序：SqlSessionFactoryBuilder-->SqlSessionFactor-->SqlSession

整体代码

数据库：myBatis简单全面_第3张图片

pom.xml：规定打包方式和引入依赖




  4.0.0

  com.jmm
  mybatis-001-introduction
  1.0.0
  jar

  mybatis-001-introduction
  
  http://www.example.com

  
    UTF-8
    1.7
    1.7
  

  
    
      junit
      junit
      4.11
      test
    

    
      org.mybatis
      mybatis
      3.5.10
    

    
      mysql
      mysql-connector-java
      8.0.30
    
  

  
    
      
        
        
          maven-clean-plugin
          3.1.0
        
        
        
          maven-resources-plugin
          3.0.2
        
        
          maven-compiler-plugin
          3.8.0
        
        
          maven-surefire-plugin
          2.22.1
        
        
          maven-jar-plugin
          3.0.2
        
        
          maven-install-plugin
          2.5.2
        
        
          maven-deploy-plugin
          2.8.2
        
        
        
          maven-site-plugin
          3.7.1
        
        
          maven-project-info-reports-plugin
          3.0.0

mybatis-config.xml：文件放置位置

myBatis简单全面_第4张图片

看到这里，代码语句或许有疑惑，先别急先让程序跑起来后面会解释。 

CarMapper.xml：主要编写SQL语句，注意格式








    
        insert into t_car(id,car_num,brand,guide_price,produce_time,car_type)
        value (null,'1003','丰田霸道',30.0,'2000-10-11','燃油车')
    


MyBatisintrodyctiojTest
public class MyBatisCompleteTest {

    public static void main(String[] args) {
        SqlSession sqlSession =null;
        try {
            //        获取SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            //        获取SqlSessionFactory对象
//        Resources.getResourceAsStream（）：获取文件路径
//        Resources.getResourceAsStream默认从根路径下找资源，这里"mybatis-config.xml"直接放到了根路径下，所以直接写
            //        一个数据库对应一个SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"));
//     获取SqlSession对象,开启回话，底层开启事务
            sqlSession = sqlSessionFactory.openSession();
            //        执行SQL语句
            int count = sqlSession.insert("insertCar");
            System.out.println("输入条数="+count);
//            没有异常提交事务
            sqlSession.commit();
        } catch (Exception e) {
//            发生异常回滚事务
            if(sqlSession!=null){
                sqlSession.rollback();
            }
            e.printStackTrace();
        }finally {
//            关闭回话释放资源
            if(sqlSession!=null){
                sqlSession.close();
            }
        }
    }

 刷新数据库表myBatis简单全面_第5张图片

myBatis日志集成框架logback

引⼊⽇志框架的⽬的是为了看清楚mybatis执⾏的具体sql。

这个是myBatis自带的，是标准⽇志组件，只需要在mybatis-config.xml⽂件中添加以下配置：

也可以集成其他的⽇志组件，例如：log4j，logback等。

第⼀步：引⼊logback和log4j相关依赖

 
      ch.qos.logback
      logback-classic
      1.2.3
    
    
      log4j
      log4j
      1.2.17

第⼆步：引⼊logback相关配置⽂件（⽂件名叫做logback.xml或logback-test.xml，放到类路径当中）这个文件名称必须叫logback.xml,放在根目录文件下。这个文件可直接复制




    
        

            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -%msg%n

可以配置也可以配置

结果：

myBatis简单全面_第6张图片

 使用myBatis完成CRUD（增删改查）

什么是CRUD

c：Create增

R：Retrieve查

u：update改

D：delete删

 上述案例我们的SQL语句中字段值是写死的，这种在实际开发是不推荐的。

    
        insert into t_car(id,car_num,brand,guide_price,produce_time,car_type)
        value (null,'1003','丰田霸道',30.0,'2000-10-11','燃油车')

在JDBC中我们使用？占位符传值，那马仔mybatis中我们使用和？等效的#{} 作为占位符

首先我先写了一个工具类，避免写测试写的多时要写一些重复的代码

public class SqlSessionUtil {

//    工具类的构造方法一般都是私有化的
//    工具类中所有的方法都是静态的，直接采用类名即可调用，不需要new对象
//    为了防止new对象构造方法私有化
    private SqlSessionUtil(){}
    private static SqlSessionFactory sqlSessionFactory;
//    因为一个sqlSessionFactory对应一个数据库，对单个数据库操作时只需创建一个即可
    static{
        try {
            sqlSessionFactory = new SqlSessionFactoryBuilder().
                    build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static SqlSession openSession(){
        return sqlSessionFactory.openSession();
    }
}

增：

通过map集合给一个SQL语句传值

public class CarMapperTest {
    @Test
    public void testInsertCar(){

        SqlSession sqlSession = SqlSessionUtil.openSession();
        Map map=new HashMap<>();
        map.put("k1","1111");
        map.put("k2","比亚迪");
        map.put("k3",10.0);
        map.put("k4","2020-11-11");

        int count = sqlSession.insert("insertCar",map);
        System.out.println(count);

        sqlSession.commit();
        sqlSession.close();
    }
}





    
        insert into t_car(id,car_num,brand,guide_price,produce_time,car_type)
        value (null,#{k1},#{k2},#{k3},#{k4},#{k5})

通过POJO（又称bean类）对象给一个SQL语句传值

首先根据数据库字段创建POJO包下的类，并生成相应的构造、get、set、tostring方法

public class Car {
//    数据库表中的字段应该和破击类的属性一一对应
//    建议使用包装类，这样可以防止null的问题

    private Long id;
    private String carNum;
    private String brand;
    private Double guidePrice;
    private String produceTime;
    private String carType;

测试类

public class CarMapperTest {
    @Test
    public void testInsertCarPOJO(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        Car car = new Car(null,"3333","比亚迪秦",30.0,"2022-01-11","新能源");
    int count = sqlSession.insert("insertCar",car);
        System.out.println(count);

        sqlSession.commit();
        sqlSession.close();
    }

SQL语句格式（与POJO类里的属性相对应）

   
        insert into t_car(id,car_num,brand,guide_price,produce_time,car_type)
        value (null,#{carNum},#{brand},#{guidePrice},#{produceTime},#{carType})

删：

        
        
            delete from t_car where id=#{id}
        
   @Test
    public void testDeleteCar(){
        SqlSession sqlSession =SqlSessionUtil.openSession();
      int count=  sqlSession.delete("a",9);
        System.out.println(count);
        sqlSession.commit();
        sqlSession.close();

    }

改： 


            update t_car set car_num=#{carNum},brand=#{brand},guide_price=#{guidePrice},produce_time=#{produceTime},car_type=#{carType} where id=#{id}
        
    @Test
    public void testUpdateById(){
        SqlSession sqlSession= SqlSessionUtil.openSession();
        Car car = new Car(4L,"9999","凯美瑞",30.3,"1999-01-19","燃油车");
  int count = sqlSession.update("updataById",car);
        System.out.println(count);

        sqlSession.commit();
        sqlSession.close();
    }

查询

注意：查询是会产生一个结果集的，一起看一下mybatis是怎样处理查询结果集的

对于⼀个查询语句来说，你需要指定它的“结果类型”或者“结果映射

查询一条数据

测试类

    @Test
    public void testSelectById(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        Object car = sqlSession.selectOne("selectById",1);
        System.out.println(car);
        sqlSession.close();
    }

查询结果：注意看后面几个字段都是null值，但是在数据库这些字段都是有值的

 原因是：查询结果的字段名和java类的属性名对应不上的

数据库字段名和属性类名

myBatis简单全面_第7张图片    myBatis简单全面_第8张图片

 解决方法：可以采用暗色关键字起别名，当然还有其他方法别着急，我们慢慢看。

更改后的查询语句

 

 查询所有数据（List集合）

 测试类

@Test
    public  void testSelectAll(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        List cars = sqlSession.selectList("selectAll");
        cars.forEach( car -> System.out.println(car));
        sqlSession.close();
    } 
  
到这里增删改查内容已结束，有个知识点没提及，就是CarMapper.xml文件中美好的 namespace
 
  
他称作命名空间，主要是用来解决SQLid冲突的。
 
  
当你有两个XxxxMapper.xml文件时，里面select的id都是“selectCar1”，此时测试文件文件调用select语句会不知道调用那个文件的select，会报错
 
  
解决方法：测试文件中的id写成“namespace.id”
 
  
Listcars = sqlSession.selectList("car2.selectCarAll");
 
  
myBatis简单全面_第9张图片
 
  
增删改查阶段结束了，只是直到配置文件格式怎么写，但是配置文件各行代码还是 不明确，没关系下面就开始分析配置文件语句。
 
  
MyBatis核⼼配置⽂件详解
 
  
将mybatis-config.xml文件先拿过来
 
  
myBatis简单全面_第10张图片
 
  
     
   
  •  configuration:他是跟标签，表示配置信息，一般一个配置文件只有一个该标签
    •  
   
  • environments：表示多个环境，mybatis可以配置多个数据源。default属性：表示默认使用那个环境，default后面填写的是enviroment的id。default的值只需要和enviorment的id值一致即可。 
    •  
   
  • enviorment：具体的环境配置（事务管理器的配置+数据源的配置）他的id代表当前环境的唯一标识，和enviorments后面的default值一样。当有多个enviorment时，enviorments的default后面填写的其中一个，就代表整个id的enviorment是默认环境。一个enviroment代表一个数据库，对应一个SqlSessionFactory对象。
    •  
   
  • transactionManager：配置事务管理器  type属性：指定事务管理器具体是用什么方式（JDBC：有事务、MANAGED：无事务）
    •  
   
  • dataSource：指定数据源 ，它的作用主要是给程序员提供Connection接口                                type属性：用来指定具体的数据库连接池策略 ，type=“”[UNPOOLED|POOLED|JNDI]                  UNPOOLED:不使用数据库连接池技术，每一次请求过来之后，都是创建的新的Collection对象                                                                                                                                 POOLED：采用mybatis自己的数据库连接池                                                                     JDNI：继承第三方数据库连接池，他是一套规范，大部分的eb容器都实现该规范，如Tomcat、jettry等后期会使用Tomcat实现，首先需要将druid、c3p0、dbcp等数据库连接池集成到Tomcat中
    •  
   
  • mappers:在mappers标签中可以配置多个SQL映射文件路径
    •  
   
  • mapper：配置某个SQL映射文件的路径 resource属性：使用相对路径的资源引用方式
    •  
  
 
  
SqlSessionFactoryBuilder、SqlSessionFactory对象作用域
 
  
     
   
  • SqlSessionFactoryBuilder:一旦创建了SqlSessionFactory就不必再需要他，不需要一直保留着它
    •  
   
  • SqlSessionFactory:一旦创建就应该在运行期间一直存在，没有任何理由丢弃它或者创建另一个实例，除非有多个数据库
    •  
   
  • SqlSession：每个线程都应该有自己的SqlSession实例，SqlSession的实例是不安全的，因此不能被共享。因为一个线程duiyingyigeshiwu，所以在这个鬼事物里SqlSession应该始终是同一个，所以将它放在ThreadLocal 中，它是线程的局部变量，这些变量只能在这个线程内被读写，在其他线程内是无法访问的。 ThreadLocal 定义的通常是与线程关联的私有静态字段。下面转账案例中就会使用
    •  
  
 
  
 
  
properties 标签的配置
 
  
 
   
引入properties文件，使数据库信息修改时可以不再代码内部处理
 
  
 
  
创建properties文件
 
  
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=12345678
 
  
在mybatis- config.xml引入配置文件
 
  




    
    
        
            
            
            
                
                
                
            

        
    
    
        
    

 
  
在WEB中应用MyBatis（用MVC架构）
 
  
以银行转账为例
 
  
适用技术：HTML+Servlet+MyBatis
 
  
一、数据库准备
 
  
myBatis简单全面_第11张图片
 
  
 myBatis简单全面_第12张图片
 
  
 
  
二、创建项目
 
  
myBatis简单全面_第13张图片
 
  
将为web.xml文件版本改为高版本
 
  




 
  
 Pom.xml 打包方式为war
 
  
引入依赖
 
  

  4.0.0
  com.test
  mybatis-002-web
  war
  1.0

  mybatis-002-web Maven Webapp
  http://maven.apache.org

  
  UTF-8
  17
  17
  

  
    
      org.mybatis
      mybatis
      3.5.1
    
    
      mysql
      mysql-connector-java
      5.1.9
    
    
      ch.qos.logback
      logback-classic
      1.2.11
    
    
      jakarta.servlet
      jakarta.servlet-api
      5.0.0
      provided
    
  
  
    mybatis-002-web
    
      
        
          maven-clean-plugin
          3.1.0
        
        
          maven-resources-plugin
          3.0.2
        
        
          maven-compiler-plugin
          3.8.0
        
        
          maven-surefire-plugin
          2.22.1
        
        
          maven-war-plugin
          3.2.2
        
        
          maven-install-plugin
          2.5.2
        
        
          maven-deploy-plugin
          2.8.2
        
      
    
  


 
  
编写相关配置文件：
 
  
myBatis简单全面_第14张图片
 
  
jdbc.properties
 
  
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC&characterEncoding=utf-8&autoReconnect=true

jdbc.username=root
jdbc.password=12345678

 
  
mybatis-config.xml
 
  




    
    
        
            
            
                
                
                
                
            

        
    
    
        
    


 
  
CarMapper.xml（这个文件应该等到编写了dao里边定义的数据库方法后在编写，我只是将它放到这里）
 
  




    
        update t_act set balance = #{balance} where actno=#{actno}
    

 
  
 log可以引用前面的，到这里就该编写前端界面
 
  



    
    银行转账账户




  转出账户：

  转入账户：

  装账金额：

  




 
  
到这里要编写具体的转账实现
 
  
首先搭好MVC架子，准备包
 
  
myBatis简单全面_第15张图片
 
  
 定义pojo类Account
 
  
package com.test.pojo;

/**
 * 账户类
 * @acount 老杜
 * @version 1.0
 * @since 1.0
 */
public class Account {
    private Long id;
//    账户号
    private String actno;
//    余e
    private Double balance;

    public Account() {
    }

    public Account(Long id, String actno, Double balance) {
        this.id = id;
        this.actno = actno;
        this.balance = balance;
    }

    public Long getID() {
        return id;
    }

    public void setID(Long ID) {
        this.id = ID;
    }

    public String getActno() {
        return actno;
    }

    public void setActno(String actno) {
        this.actno = actno;
    }

    public Double getBalance() {
        return balance;
    }

    public void setBalance(Double balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "Account{" +
                "ID=" + id +
                ", actno='" + actno + '\'' +
                ", balance=" + balance +
                '}';
    }
}


 
  
准备工具类
 
  
package com.test.utils;

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 java.io.IOException;

public class SqlSessionUtil {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            sqlSessionFactory = new SqlSessionFactoryBuilder().
                    build(Resources.getResourceAsStream("mybatis-config.xml"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
//    ThreadLocal用来存放当前线程的副本是AccountServiceImpl里创建的sqlsession
    private  static  ThreadLocal local = new ThreadLocal<>();
    public static SqlSession openSession(){
//        返回当前线程局部变量的副本
        SqlSession sqlSession = local.get();
        if (sqlSession == null){
           sqlSession = sqlSessionFactory.openSession();
//           将sqlsession对象绑定在当前线程也就是将当前线程局部变量的副本设置为指定的值
            local.set(sqlSession);
        }
        return sqlSession;
    }
/**
 * 关闭sqksession对象
 *
 */
public  static void close(SqlSession sqlSession){
    if(sqlSession!=null){
        sqlSession.close();
//        移除sqlsession对象和当前现成的绑定关系应为tomcat支持线程池，因为用过线程T1,可能下一次还会用到T1
//        也就是删除此线程局部变量副本设置的指定值
        local.remove();
    }
}
}
 
  
编写dao里的AccountDao接口和AccountDaoImpl实现类
 
  
     
   
  • 需要有查询余额的方法：selectByActno
    •  
   
  • 转账后 更新各个账户的方法
    •  
  
 
  

import com.test.pojo.Account;
import org.apache.ibatis.annotations.Mapper;

/**
 * 账户的dao对象负责t_cat标中数据的增删改查
 *
 */

public interface AccountDao {

    /**
     * 根据账号查询账户信息
     *
     * @param actno 账号
     * @return
     */
    Account selectByActno(String actno);

    /**
     * 更新账户信息
     * 因为要更新账户所以要吧整个账户对象Account传进来
     * @param act 被更新的账户对象
     * @return 1 更新成功 其他失败
     */
    int updateActno(Account act);
}
 
  
package com.test.dao.impl;

import com.test.dao.AccountDao;
import com.test.pojo.Account;
import com.test.utils.SqlSessionUtil;
import org.apache.ibatis.session.SqlSession;

public class AccountDaoImpl implements AccountDao {
    @Override
    public Account selectByActno(String actno) {
//        因为AccountServiceImpl里创建了sqlsession对象，所以在调用openSession方法时不走if，因为创建过一次不为空所以他们是一个sqlsession对象
        SqlSession sqlSession = SqlSessionUtil.openSession();
        Account account = sqlSession.selectOne("selectByActno",actno);

        return account;

    }

    @Override
    public int updateActno(Account act) {
        SqlSession sqlSession = SqlSessionUtil.openSession();
        int count = sqlSession.update("updatByActno", act);

        return count;
    }
}

 
  
编写AccountService接口和AccountServiceimpl
 
  
package com.test.service;

import com.test.exceptions.MoneyNotEnoughException;
import com.test.exceptions.TransferException;

import javax.xml.transform.TransformerException;

/**
 * 账户业务类
 * @author :老杜
 * @version 1.0
 * @since 1.0
 * 之所以要有接口，是因为层与层之间要用借口链接，降低耦合
 * 业务类中的每个方法起名时要见明知意
 */
public interface AccountService {
    /**
     * 账户转账业务
     * @param fromActno 转出账号
     * @param toActno 转入账号
     * @param money 转账金额
     */
    void transfer(String fromActno,String toActno,double money)
            throws MoneyNotEnoughException,TransferException;
}
 
  
package com.test.service.impl;

import com.test.dao.AccountDao;
import com.test.dao.impl.AccountDaoImpl;
import com.test.exceptions.MoneyNotEnoughException;
import com.test.exceptions.TransferException;
import com.test.pojo.Account;
import com.test.service.AccountService;
import com.test.utils.SqlSessionUtil;
import org.apache.ibatis.session.SqlSession;

/**
 * fromAct：转出账户
 * toActno：转入账户
 * money：转账金额
 * balance：余额
 */
public class AccountServiceImpl implements AccountService {


    private final AccountDao account = new AccountDaoImpl();
    @Override
    public void transfer(String fromActno, String toActno, double money) throws MoneyNotEnoughException,TransferException {
        SqlSession sqlSession = SqlSessionUtil.openSession();

        //        1.判断转出账户余额是否充足
        Account fromAct = account.selectByActno(fromActno);

        //        2。如果余额不足提示用户
        if(fromAct.getBalance()
 
  
编写web包下的AccountServlet
 
  
该类主要用于接收前端传过来的文本框信息 和调用成功与异常应反悔的界面，不必事先具体的事物
 
  
package com.test.service.impl;

import com.test.dao.AccountDao;
import com.test.dao.impl.AccountDaoImpl;
import com.test.exceptions.MoneyNotEnoughException;
import com.test.exceptions.TransferException;
import com.test.pojo.Account;
import com.test.service.AccountService;
import com.test.utils.SqlSessionUtil;
import org.apache.ibatis.session.SqlSession;

/**
 * fromAct：转出账户
 * toActno：转入账户
 * money：转账金额
 * balance：余额
 */
public class AccountServiceImpl implements AccountService {


    private final AccountDao account = new AccountDaoImpl();
    @Override
    public void transfer(String fromActno, String toActno, double money) throws MoneyNotEnoughException,TransferException {
        SqlSession sqlSession = SqlSessionUtil.openSession();

        //        1.判断转出账户余额是否充足
        Account fromAct = account.selectByActno(fromActno);

        //        2。如果余额不足提示用户
        if(fromAct.getBalance()
 
  
是用Javassist生成DaoImpl
 
  
使用Javassist可以只写接口不写接口实现类，Javassist可以帮你实现接口实现类的实现和对象的创建，比如转账项目不再写AccountDaoImpl，直接加上Javassist语句
 
  
 private AccountDao account = 
SqlSessionUtil.openSession().getMapper(AccountDao.class);
 
  
完整代码
 
  
public class AccountServiceImpl implements AccountService {


    //private final AccountDao account = new AccountDaoImpl();
    private AccountDao account = SqlSessionUtil.openSession().getMapper(AccountDao.class);
    @Override
    public void transfer(String fromActno, String toActno, double money) throws MoneyNotEnoughException,TransferException {
        SqlSession sqlSession = SqlSessionUtil.openSession();

        //        1.判断转出账户余额是否充足
        Account fromAct = account.selectByActno(fromActno);

        //        2。如果余额不足提示用户
        if(fromAct.getBalance()
 
  
mybatis小技巧
 
  
#{}和${}区别
 
  
首先看一个查询之间的区别
 
  


 
  
 
   
我们领查询的条件carType=新能源

#{}的执行结果：

 
   
[main] DEBUG c.p.mybatis.mapper.CarMapper.selectByCarType - ==> 
 Preparing: select id, car_num as carNum, brand, guide_price as guidePrice, produce_time as produceTime, car_type as carType from t_car where car_type = ?
[main] DEBUG c.p.mybatis.mapper.CarMapper.selectByCarType - ==> 
Parameters: 新能源(String)
[main] DEBUG c.p.mybatis.mapper.CarMapper.selectByCarType - <==    
  Total: 2
 
   
${}的执行结果：

 
   
[main] DEBUG c.p.mybatis.mapper.CarMapper.selectByCarType - ==>
  Preparing: select id, car_num as carNum, brand, guide_price as guidePrice, produce_time as produceTime, car_type as carType from t_car where car_type = 新能源
[main] DEBUG c.p.mybatis.mapper.CarMapper.selectByCarType - 
==> Parameters:
 
   
注意看where car_type = 后面的区别，#{}：where car_type =？   ${}：where car_type =新能源。
 
   
    #{}: 底层使用PreparedStatement。特点：先进行SQL语句的编译，然后给SQL语句的占位符问号?传值。可以避免SQL注入的风险。
    ${}：底层使用Statement。特点：先进行SQL语句的拼接，然后再对SQL语句进行编译。存在SQL注入的风险。
    优先使用#{}，这是原则。避免SQL注入的风险。
 
   
Sql注入是指web应用程序对用户输入数据的合法性没有判断或过滤不严，攻击者可以在web应用程序中事先定义好的查询语句的结尾上添加额外的SQL语句，在管理员不知情的情况下实现非法操作，从而进一步得到相应的数据信息。
 
  
 
  
那么问题来了我们什么时候使用${}呢
 
  
先看下面的查询代码
 
  
   
   
 
  
#{}的执行结果：
Preparing: select
                id, car_num as carNum, brand, guide_price as guidePrice, produce_time as produceTime, car_type as carType
           from t_car order by produce_time ?
Parameters: asc(String)
将它转换一下：
select
    id, car_num as carNum, brand, guide_price as guidePrice, produce_time as produceTime, car_type as carType
from t_car order by produce_time 'asc'

${}的执行结果：
Preparing:
    select id, car_num as carNum, brand, guide_price as guidePrice, produce_time as produceTime, car_type as carType
    from t_car order by produce_time asc
Parameters:
 
  
 
   
1.这种我们需要将关键字放进sql语句中，只能使用${}，因为#{}是以值的形式放到SQL语句当中的而不是关键字。
 
  
 
  
 
   
2.向sql语句中拼接表名时，使用${}
 
   
    比如，在业务中，如果数据量较大的话，会存在分表情况
 
   
        日志表：如果只有一张表，这张表每天都会产生很多log，漫漫的这个表中的数据就会很多，此时我们可以让他每天生成一个新表。以每天的日期命名：t_log_20221016. t_log_20221017......
 
   
想知道某一天的信息，对其拼串即可（因为要把表名作为关键字，而不是具体参数，所以使用${}）
 
  
 
  
 
   
批量删除：
 
   
对应的SQL语句：
 
   
delete from t_car where id=1 or id=2;

delete from t_car where id in(1,2,3)
 
   
 假设使用in，前段传来1，2，3 这时该用${}
 
   
 
  
 
  
 
   
模糊查询：like
     需求：根据汽车品牌进行模糊查询
         select * from t_car where brand like '%奔驰%';
         select * from t_car where brand like '%比亚迪%';
 
   
    第一种方案：
         '%${brand}%'
     第二种方案：concat函数，这个是mysql数据库当中的一个函数，专门进行字符串拼接
         concat('%',#{brand},'%')
     第三种方案：比较鸡肋了。可以不算。
         concat('%','${brand}','%')
    第四种方案：（常用）
         "%"#{brand}"%"
 
   
 
   
5. 关于MyBatis中别名机制:
     
         
         
         
 
   
        
         
         
 
   
        （常用）
         
     
 
   
    所有别名不区分大小写。
     namespace不能使用别名机制。
 6. mybatis-config.xml文件中的mappers标签。
      要求类的根路径下必须有：CarMapper.xml
      要求在d:/下有CarMapper.xml文件
     
 
   
    mapper标签的属性可以有三个：
         resource:这种方式是从类的根路径下开始查找资源。采用这种方式的话，你的配置文件需要放到类路径当中才行。
         url: 这种方式是一种绝对路径的方式，这种方式不要求配置文件必须放到类路径当中，哪里都行，只要提供一个绝对路径就行。这种方式使用极少，因为移植性太差。
         class: 这个位置提供的是mapper接口的全限定接口名，必须带有包名的。
             思考：mapper标签的作用是指定SqlMapper.xml文件的路径，指定接口名有什么用呢？
                 
                 如果你class指定是：com.powernode.mybatis.mapper.CarMapper
                 那么mybatis框架会自动去com/powernode/mybatis/mapper目录下查找CarMapper.xml文件。
             注意：也就是说：如果你采用这种方式，那么你必须保证CarMapper.xml文件和CarMapper接口必须在同一个目录下。并且名字一致。CarMapper.xml文件是在resource文件下，CarMapper接口在Java文件下 ，所以只需要在resources目录下创建一个和CarMapper接口的报名一样的目录即可。
             CarMapper接口-> CarMapper.xml
             LogMapper接口-> LogMapper.xml
             ....
 
   
    提醒！！！！！！！！！！！！！！！！！！！！！！！
         在IDEA的resources目录下新建多重目录的话，必须是这样创建：
             com/powernode/mybatis/mapper
         不能这样：
             com.powernode.mybatis.mapper
 
   
但如果class较多的话，可以写cheng包的方式
 
   



 
   
 
  
 
  
小技巧之typeAliases 
 
  
我们先来看看CarMapper.xml文件
 
  



 
    
    

 
  
我们可以看到resulType属性是用来制定查询结果集封装类型的，但这个名字太长，硬刺我们可以给他起个别名，我们可以在mybatis-config.xml中使用typeAliases
 
  
第一种：该段代码应该放在envorments标签上，配置文件引用下边
 
  




 
  
type:指定给哪个类起别名
 
  
alias：别名（不区分大小写）
 
  
虽然这样一定程度上减少了代码书写的复杂度，但如果有100行代码要写resultType，那么就要写100行
 
  
所以有了第二种，也是最常用的一种
 
  
第二种：只需要指定包名，该包下的所有勒都会起别名，（别名为类名）不区分大小写
 
  

  

 
  
CarMapper.xml：myBatis简单全面_第16张图片
 
  
idea配置文件模版 
 
  
myBatis简单全面_第17张图片
 
  
 myBatis简单全面_第18张图片
 
  
 插入数据时获取自动生成的主键
 
  
两个属性：useGeneratedkeys=“true”：使用自动生成的主建值
 
  
                keyProperty=“ID”指定主建值赋值给对象的那个属性
 
  

insert into t_car values(null.#{carNum}

 
  
这里id是null，但输出id是有结果的
 
  
mybatis参数处理
 
  
单个简单参数类型
 
  
 
   
简单类型包括：
 
   
     
    
  • byte、short、int、long、double、char
    •  
    
  • Byte、Short、Integer、Float、Double、Character
    •  
    
  • String
    •  
    
  • Java.util.Date
    •  
    
  • java.sql.Date
    •  
   
 
  
 
  
建表
 
  
myBatis简单全面_第19张图片
 
  
myBatis简单全面_第20张图片 需求根据接口中四种类型进行查询
 
  
注意date类型和Charsert类型
 
  
StudentMapper.java
 
  
public interface StudentMapper {

    List selectById(Long id);
    List selectByName(String name);
    List selectByBirth(Date birth);
    List selectBySex(Character sex);
}
 
  
 StudentMapper.xml
 
  



    

    

    

    

 
  
studentMapperTest.java:注意看日期类型的和Character类型（第三个和第四个）
 
  
public class StudentMapperTest {
@Test
    public void testselectById(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List students = mapper.selectById(1L);
    students.forEach(student -> System.out.println(student));
        sqlSession.close();
    }

@Test
    public void testSelectByName(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List students = mapper.selectByName("张三");
        students.forEach(student -> System.out.println(student));
        sqlSession.close();
    }

    @Test
    public void testSelectByBirth() throws ParseException {
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birth = sdf.parse("1980-10-11");
        List students = mapper.selectByBirth(birth);
        students.forEach(student -> System.out.println(student));
        sqlSession.close();
    }
@Test
    public void testSelectBySex(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        Character sex = Character.valueOf('男');
        List students = mapper.selectBySex(sex);
        students.forEach(student -> System.out.println(student));
        sqlSession.close();

    }
}

 
  
Map参数类型 处理
 
  
这种方式是手动封装Map集合，将每个条件以key和value的形式存在集合中。
 
  
接口格式
 
  
  int insertStudentByMap (Map map);


 
  
 
        insert into t_student(id,name,age,height,sex,birth)
values (null,#{姓名},#{年龄},#{身高},#{性别},#{生日})
    
 
  
@Test
    public void testinsertStudentByMap(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        Map map = new HashMap<>();
       map.put("姓名","赵六");
       map.put("年龄",20);
       map.put("身高",1.81);
       map.put("性别",'男');
       map.put("生日",new Date());

        mapper.insertStudentByMap(map);
        sqlSession.commit();
        sqlSession.close();
    }
 
  
实体类参数
 
  
int insertStudentByPOJO(Student student);

 
  
 
        insert into t_student(id,name,age,height,sex,birth)
        values (null,#{name},#{age},#{height},#{sex},#{birth})
    
 
  
    @Test
    public void testtestinsertStudentByPOJO(){

        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        Student student = new Student();
        student.setName("张飞");
        student.setAge(22);
        student.setHeight(1.90);
        student.setSex('男');
        student.setBirth(new Date());
         mapper.insertStudentByPOJO(student);
         sqlSession.commit();
         sqlSession.close();
    }
 
  
多个参数传递分两种情况
 
  
第一种
 
  
* 多参数
* 这种情况mybatis会自动创建一个Map集合 并且参数形式如下
* map.put("arg0",name}
* map.put("arg1",name}
* map.put("param1",name}
* map.put("param2",name}

 
  
代码
 
  
 
   
List selectByNameAndSex(String name,Character sex)

 
  
 
  
 
 
  
  public void testselectByNameAndSex(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List students = mapper.selectByNameAndSex("张三", '男');
        students.forEach(student -> System.out.println(student));
        sqlSession.close();
    }
 
  
 第二种常用
 
  
* Param注解:底层是一个map集合
* mybatis框架的底层实现原理
* map.Put(""name",name)
* map.put("sex",sex)
*
* @Param name 类型 name
* @Param sex   类型 sex
 
  
 List selectByNameAndSex2(@Param("name") String name,@Param("sex") Character sex);

 
  
   
 
  
  @Test
    public void testselectByNameAndSex2(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List students = mapper.selectByNameAndSex2("张三",'男');
        students.forEach(student -> System.out.println(student));
        sqlSession.close();


    }
 
  
查询专题之返回
 
  
根据id查询car信息，这里只能返回一条数据。 其他的写法和上百遍的一样这里不不不在详细写
 
  
Car selectById(Long id);
 
  
获取所有的car，需要一个list集合

 
  
List selectAll();
 
  
根据品牌进行模糊查询
这里的模糊查询的结果有一个,如果有多条结果会报错
 
  
如果要返回多条使用list即可
 
  
Car selectBByBrandLike(String brand);


ListselectById2(String  brand);

 
  
 
  
  @Test
    public void selectBByBrandLike(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        Car car = mapper.selectBByBrandLike("大众");
        System.out.println(car);
        sqlSession.close();
    }
 
  
* 根据id获取汽车信息。将汽车信息放到Map集合中。
* 注意 这里是返回Map，并不是返回某个实体类
* 但这种只能返回一条，看下面map对应的
* | id  | car_num | brand    | guide_price | produce_time | car_type |
*      * +-----+---------+----------+-------------+--------------+----------+
*      * | 158 | 1111    | 比亚迪汉 |        3.00 | 2000-10-10   | 新能源   |
*      * +-----+---------+----------+-------------+--------------+----------+
*      *
*      * Map
*      *     k                 v
*      *     -----------------------
*      *     "id"             158
*      *     "car_num"        1111
*      *     "brand"          比亚迪汉
 
  
Map selectByIdRetMap(String brand);
 
  
   应为返回的map集合，没有对应的实体类，所以这里的type应该是java.util.Map 

 
  
 
 
  
 
  
  @Test
    public void testselectByIdRetMap(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        Map car = mapper.selectByIdRetMap("大众");
        System.out.println(car);
        sqlSession.close();

    }
 
  
如果要返回多条map集合可以使用list
 
  
List> selectAllRetListMap();
 
  
 
  
 @Test
    public void testselectAllRetListMap(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        List> maps = mapper.selectAllRetListMap();
        maps.forEach(map -> System.out.println(map));
        sqlSession.close();
    }
 
  
查询所有的car，返回一个大Map集合
* Map集合的key是每条记录的主建值，这里是id
* map集合的value是每条记录所有值，这种的好处
跟上边比查询效率高
比如：你需要查询ID=3的，上边需要便利三个{}才能找到id=3



er这种只需要根据key=3快速找到* {

*     1={...}
*     2={...}
* } 
 
  
    @MapKey("id")//将查询结果的id值作为整个大Map集合的key。
    Map> selectAllRetMap();
 
  
    

 
  
@Test
    public void testSelectAllRetMap(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
         Map> maps = mapper.selectAllRetMap();
    System.out.println(maps);
        sqlSession.close();
    }
 
  
 
  
还记得我们结果列名和Java属性名对不上我们怎么处理的吗
 
  
我们选择了起别名
 
  
现在我们有了更好的机制
 
  
使用resultMap进行结果映射或者使用驼峰命名映射，我们一个一个来看
 
  
resultMap
 
  
List selectAllByResultMap();

 
  
注意下面书写格式
 
  


    
    
    
    
    
    
    
    
    
    
    

    
    
 
  
@Test
    public void testSelectAllByResultMap(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        List cars = mapper.selectAllByResultMap();
        cars.forEach(car -> System.out.println(car));
        sqlSession.close();

    }
 
  
 
  
驼峰命名前提：
 
  
属性名遵寻Java命名规范：首字母小写，后面每个单词首字母大写
 
  
数据库列名遵循sql命名规范：全部小写，单词之间采用下划线分割
 
  
myBatis简单全面_第21张图片
 
  
在mybatis-config中配置：
 
  
 
        
    
 
  
 List selectAllByMapUnderscoreToCamelCase();
 
  
 

 
  
@Test
    public void testSelectAllByMapUnderscoreToCamelCase(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        List cars = mapper.selectAllByMapUnderscoreToCamelCase();
        cars.forEach(car-> System.out.println(car));
        sqlSession.close();

    }
 
  
查询总记录条数
 
  
Long selectTotal();
 
  

    
 
  
  @Test
    public void testSelectTotal(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        Long total = mapper.selectTotal();
        System.out.println("总记录条数：" + total);
        sqlSession.close();
    }
 
  
动态SQL（重要）
 
  
开发中 很多业务场景都会使用到SQL语句进行动态拼接：
 
  
     
   
  •  
    批量删除，插入等
     
    •  
   
  •  
    多条件更新
     
    •  
  
 
  
下面我们介绍他的标签和用法吧
 
  
if标签
 
  
使用场景：多条件查询
 
  
需求：根据 brand 品牌   guidePrice 指导价  carType 汽车类型三个条件查询相应信息
 
  
编写接口
 
  

    List selectByMultiCondition(@Param("brand") String brand,
                                     @Param("guidePrice") Double guidePrice,
                                     @Param("carType") String carType);
 
  
具体SQL语句编写
 
  
 
   
这里加1=1 是恒成立的意思，只有加上这个条件，当三个条件都为null，也就是三个if都不走也不会报错
否则日志上的语句是select * from powernode where ，where子句后面什么都没有会报错-

 
   
if标签中test属性是必必须的
    if标签中test的属性是false和true
     如果test是true ，则if标签中的SQL语句会进行拼接，反之并不会
     当使用了@param注解，那么test中要出现@param注解指定的参数名。
       @param（"brand"）那么test这里只能使用brand
    没有使用注解时 test要出现的是：param1或 agr0
     当时用了POJO中的实体类时test使用的是POJO属性名
     在mybatis只能使用and拼接
 
  
 
  


 
  
测试 
 
  
  @Test
    public void testSelectByMultiCondition(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    //   List cars =  mapper.selectByMultiCondition("凯美瑞",3.0,"新能源");
        //List cars = mapper.selectByMultiCondition("", null, "");
        List cars = mapper.selectByMultiCondition("凯美瑞", null, "");
       // List cars = mapper.selectByMultiCondition("", 2.0, "新能源");
       cars.forEach(car -> System.out.println(car));
sqlSession.close();
    }
 
  
where标签 
 
  
 
   
所有条件都为空时，where标签保证不会生成where子句
 
   
会自动去除某些田间前面多余的and和or
 
  
 
  
接口
 
  
 List selectByMultiConditionWithWhere(@Param("brand") String brand,
                                              @Param("guidePrice") Double guidePrice,
                                              @Param("carType") String carType);
 
  
 
   
这里使用了where表情不用再加恒成立的语句 
 
  
 
  
 
  
@Test
    public void testSelectByMultiConditionWithWhere(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
           List cars =  mapper.selectByMultiConditionWithWhere("凯美瑞",3.0,"新能源");
        //List cars = mapper.selectByMultiConditionWithWhere("", null, "");
       // List cars = mapper.selectByMultiConditionWithWhere("比亚迪", null, "");
        // List cars = mapper.selectByMultiConditionWithWhere("", 2.0, "新能源");
        cars.forEach(car -> System.out.println(car));
        sqlSession.close();
    }
 
  
trim标签 
 
  
 
   
他可以动态的管理前后缀
 
   
四个属性
 
   
prefix：加前缀
suffix：加后缀
prefixOverrides：删除前缀
suffixOverrides：删除后缀
 
  
 
  
List selectByMultiConditionWithTrim (@Param("brand") String brand,
                                          @Param("guidePrice") Double guidePrice,
                                          @Param("carType") String carType);
    /**
 
  
  
 
  
   @Test
    public void testSelectByMultiConditionWithTrim(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        List cars =  mapper.selectByMultiConditionWithTrim("凯美瑞",3.0,"新能源");
        //List cars = mapper.selectByMultiConditionWithTrim("", null, "");
        // List cars = mapper.selectByMultiConditionWithTrim("比亚迪", null, "");
        // List cars = mapper.selectByMultiConditionWithTrim("", 2.0, "新能源");
        cars.forEach(car -> System.out.println(car));
        sqlSession.close();
    }
 
  
 set标签
 
  
 
   
主要是用在update语句中，用该关键字去掉多余的“，”  以及只更改需要的值时其他字段不会为null
 
  
 
  
  int updateBySet(Car car);
 
  
sql语句中如果我们使用以前的方式编写 
 
  
    
update powernode
set
      car_num = #{carNum},
       brand = #{brand},
       guide_price = #{guidePrice},
       produce_time = #{produceTime},
       car_type = #{carType}
        where id = #{id}
    

 
  
当我们更改这条语句
 
  
Car car = new Car(12L,null,"霸道",null,null,"燃油）
 
  
本来数据库
 
  
 
  
执行完后：其他字段为null 但使用set标签不会出现这种情况
 
  
  
    
        update powernode

    
        car_num =#{carNum},
    
    
        brand =#{brand},
    
    
        guide_price =#{guidePrice},
    
    
        produce_time =#{produceTime},
    
    
        car_type =#{carType},
    

            where
id =#{id}
    
 
  
 测试：还是那条数据我们将他恢复成都有数据后将它品牌改为大众
 
  
 public void testUpdateById(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        Car car = new Car(12L,null,"大众",null,null,"燃油车");
        mapper.updateById(car);
        sqlSession.commit();
        sqlSession.close();
    }

 
  
 
  
choose when otherwise 标签 
 
  
 
   
注意：这三个标签是一起用的
 
   
它等同于if else ：只会有一个分支被执行
 
  
 
  
myBatis简单全面_第22张图片
 
  
myBatis简单全面_第23张图片
 
  
  List selectByChoose(@Param("brand") String brand,
                             @Param("guidePrice")Double guidePrice,
                             @Param("carType") String carType);
 
  
 
  
 public void testSelectByChoose(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    List cars = mapper.selectByChoose("丰田霸道",1.0,"新能源");
        cars.forEach(car -> System.out.println(car));
        sqlSession.close();
    }
 
  
批量删除 
 
  
 
   
需要使用到foreach标签，来便利数组和集合
 
   
foreach标签的属性：
    collection：指定数组或者集合
    item：代表数组或集合中的元素
    separator：循环之间的分隔符
    open: foreach循环拼接的所有sql语句的最前面以什么开始。
    close: foreach循环拼接的所有sql语句的最后面以什么结束。

collection="ids" 第一次写这个的时候报错了，错误信息是：[array, arg0]
什么意思？
    map.put("array", 数组);
    map.put("arg0", 数组);
 
   
使用in关键字来删除 
 
  
 
  
int deleteByIds(@Param("ids") Long[] ids);
 
  
 


        delete from powernode where id in(
        
            #{id}
        
        )
    
 
  
 public void testDeleteByIds(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        Long[] ids = {1L,2L};
       int count =  mapper.deleteByIds(ids);
        System.out.println(count);
        sqlSession.commit();
        sqlSession.close();

    }
 
  
使用or关键字批量删除
 
  
 int  deleteByIds2(@Param("ids") Long[]ids);
 
  
 
        delete from powernode where(
            
                id=#{id}
            
                                       )
    
 
  
 public void testDeleteByIds2(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        Long[] ids = {3L,4L};
        int count = mapper.deleteByIds2(ids);
        System.out.println(count);
        sqlSession.commit();
        sqlSession.close();
    }
 
  
 批量插入
 
  
int insertBatch(@Param("cars") Listcars);
 
  

    insert into powernode values
    
        (

        null,#{car.carNum},#{car.brand},
         #{car.guidePrice},#{car.produceTime},#{car.carType}

        )
    

 
  
    public void testInsertBatch(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        Car car1 = new Car(null,"1000","雪弗莱",10.0,"2021-11-11","燃油车");
        Car car2 = new Car(null,"1001","雪弗莱",10.0,"2021-11-11","燃油车");
        Car car3 = new Car(null,"1002","雪弗莱",10.0,"2021-11-11","燃油车");

        Listcars = new ArrayList<>();
        cars.add(car1);
        cars.add(car2);
        cars.add(car3);
        mapper.insertBatch(cars);
    sqlSession.commit();
    sqlSession.close();
    }
 
  
 mybatis高级映射及延迟加载
 
  
数据表：这两张表存在多对一和一对一的关系
 
  
多对一：多个学生对应一个班级
 
  
一对多：一个班级对应多个学生
 
  
那在两种关系中怎样分那个是主表呢？
 
  
那个在前那个就是：多对一：多在前，学生表是主表
 
  
                                一对多：一在前半集是主表
 
  
 
  
学生表
 
  
myBatis简单全面_第24张图片
 
  
班级表 
 
  
myBatis简单全面_第25张图片
 
  
 
  
 多对一
 
  
首先我们先构建学生实体类和班级实体类
 
  
由于多个学生对应一个班级，那么学生类中应该有Clazz 的属性字段
 
  
一个班级对应多个学生那么班级类中应该有学生类的集合
 
  
myBatis简单全面_第26张图片
 
  
myBatis简单全面_第27张图片
 
  
 
   
 多对一实现有三种方式：
 
   
     
    
  • 级联属性映射
    •  
    
  • association
    •  
    
  • 分布查询（常用）
    •  
   
 
  
 
  
 级联属性映射 
 
  
需求：
 
  
根据id获取学生信息，同时获取学生关联的班级信息
 
  
 Student selectById(Integer id);
 
  
    
    
        
        

        
        
    

    
 
  
  public void testSelectById(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
       Student student =  mapper.selectById(3);
        System.out.println(student);
        sqlSession.close();
    }
 
  
 
  
association实现
 
  
Student selectByIdAssociation(Integer id);
 
  
 
   
  association :翻译为关联，一个Student对象关联一个Clazz对象
        property：提供要要映射的pojo类的属性
        javaType：用来zhiding要映射的Java类型 
 
  
 
  
  
        
        

        
            
            
        
    
    
 
  
    public  void testSelectByIdAssociation(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        Student student =  mapper.selectByIdAssociation(3);
        System.out.println(student);
        sqlSession.close();
 
  
 
  
分布查询（常用）
 
  
 
   
分布查询优点：复用性强可以重复利用 就比如下边的可以只获取学生表信息 也可以只获取班级表信息 也可以将两张表连接起来获取信息
分布查询可以充分利用他们的延迟加载/懒加载机制
  延迟加载的核心：用的时候在查询不用的时候不查询
  作用：提高性能。尽可能的不查或少查提高效率就下面的来说 我不需要第二部通过cid获取班级信息时我就不会执行这部分语句
  如果我没事用关键字开启延迟加载 那么不管你巡捕不需要获取班级变信息时 他都会查询
  怎样开启延迟加载
  association标签中添加fetchType="lazy"
  但我们在现实开发中一般不用这种方式，因为他是局部的只针对当前association关联的sql语句起作用。
  我们需要在config。xml配置setting来开启，这种是开启全局的
    
    
    那么如果我有一部分要求不不不使用延迟加载怎么办
    我们可以让fetchType="eager"  这样与当前association关联的sql语句就不会有延迟加载
 
  
 
  
第一步：根据学生id查询学生信息
 
  
第二步：根据班级编号获取班级信息
 
  
延迟加载的全局开关
 
  
 
    
 
  
StudentMapper接口
 
  
  Student selectByIdStep1(Integer sid);
 
  
ClazzMapper接口

 
  
Clazz selectByStep1(Integer cid);
 
  
StudentMapper.xml
 
  

        
        

        
    

    
 
  
ClazzMapper.xml 
 
  
 
  
  public void testSelectByIdStep1(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        Student student = mapper.selectByIdStep1(5);
   //   System.out.println(student);

       System.out.println(student.getSname());
     //   System.out.println(student.getClazz().getCname());
        sqlSession.close();
    }
 
  
 一对多
 
  
通常是在一方中有list集合
 
  
第一种collection
 
  
根据班级编号查询班级信息
 
  
Clazz selectByCollection(Integer cid);
 
  
跟多对一中 association用法相似值哦是这里使用的是collection关键字
 
  
 
        
        
        
    

    
 
  
   public void testSelectByCollection(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        ClazzMapper mapper = sqlSession.getMapper(ClazzMapper.class);
        Clazz clazz = mapper.selectByCollection(1000);
        System.out.println(clazz);
        sqlSession.close();
    }
 
  
 分步查询
 
  
第一步：根据班级编号获取班级信息。
 
  
第二部：根据班级编号查询学生信息
 
  
ClazzMapper。java
 
  
    Clazz selectByStep1(Integer cid);
 
  
StudentMapper。java
 
  
List selectByCidStep2(Integer cid);

 
  
ClazzMapper。xml 
 
  
 
        
        
        
    

    

 
  
StudentMapper。xml 
 
  
 
 
  
 @Test
    public void testSelectByStep1(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        ClazzMapper mapper = sqlSession.getMapper(ClazzMapper.class);
        Clazz clazz = mapper.selectByStep1(1000);
        //System.out.println(clazz);

        // 只访问班级名字。
        System.out.println(clazz.getCname());

        // 只有用到的时候才会去执行第二步SQL
        //System.out.println(clazz.getStus());

        sqlSession.close();
    }
 
  
 mybatis缓存
 
  
一般我们从磁盘上取数据，需要一定的时间。但如果我们取加载过一次的数据，将他第一次加载后放入jvm内存中，第二次直接从内存中去会快很多，这个在jvm内存放加载数据的过程就叫缓存。
 
  
mybatis缓存：将那个select语句查询结果放入内存中，下一次还是这条select语句的话，直接从缓存好的数据中取，不再查数据库提高效率。
 
  
mybatis缓存有
 
  
     
   
  • 一级缓存：只在当前会话中（Sqlsession）
    •  
   
  • 二级缓存：将查询到的数据存到SqlsessionFactory中
    •  
   
  • 第三方缓存：EhCache Mecache等
    •  
  
 
  
一级缓存：默认开启，不需要任何配置
 
  
二级缓存满足条件
 
  
myBatis简单全面_第28张图片
 
  
 第三方缓存EhCache
 
  
 按照以下步骤来即可
 
  
myBatis简单全面_第29张图片
 
  
myBatis简单全面_第30张图片
 
  
myBatis简单全面_第31张图片
 
  
mybatis逆向工程
 
  
正向指：Java连接数据库
 
  
逆向：根据数据库表生成pojo类sqlMapper.xml文件 一节Mapper接口文件
 
  
具体做法：借助插件
 
  
首先要明白：插件是别人写好的，别人写的时候不会知道你的数据库信息，所以要提供以下数据
 
  
     
   
  • pojo类名 包名 以及生成位置
    •  
   
  • sqlMapper.xml文件名以及生成位置
    •  
   
  • 连接数据库的信息
    •  
   
  • 指定哪些数据库表参与逆向工程
    •  
  
 
  
具体配置，按照步骤来即可
 
  
添加插件
 
  
 
    
    
        
        
            
            
                
                org.mybatis.generator
                mybatis-generator-maven-plugin
                1.4.1
                
                
                    true
                
                
                
                    
                    
                        mysql
                        mysql-connector-java
                        8.0.30
                    
                
            
        
    
 
  
配置generatorConfig.xml
 
  
这个文件只能放在跟路径resources下，且名字固定
 
  
根据里面的提示信息配置自己的数据库和包名等
 
  




    
    
        
        

        
            
            
            
            
        

        
        
        

        
        
            
            
            
            
        

        
        
            
            
        

        
        
            
        

        
        
运行插件
myBatis简单全面_第32张图片
插件成功后，生成CarMapper.xml  CarMapper.java 以及pojo下的实体类
其他的类还是需要自己创建，这个只能运行简单的增删改查
分页插件PageHelper
在数据库中我们使用limit关键字进行分页
limit（startIndex，pageSize）
startIndex：起始下标，默认为0
pageSize：每页显示的记录条数
假设已知pageNum页码和pageSizebiankeyou以下公式
startIndex=（pageNum-1）*pageSize
那么mybatis怎么分页呢
借助插件PageHelper
通过代码我们一起看一下具体使用方法
首先先把项目大架子搭起来（创建好包和配置文件）
第一步：引入依赖

        com.github.pagehelper
        pagehelper
        5.1.10
    
第二步：在mybatis-config.xml中配置以下属性，注意必须放在标签后面
  
        
    
第三步：写CarMapper.xml
有没有好奇，这里没有使用分页关键字怎么做到分页，关键来了测试文件
   @Test
    public void testSelectAll(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        // 显示第几页：页码
        int pageNum = 2;
        // 获取每页显示的记录条数
        int pageSize = 3;
        PageHelper.startPage(pageNum, pageSize);

        List cars = mapper.selectAll();
      //cars.forEach(car -> System.out.println(car));
        PageInfo carPageInfo = new PageInfo<>(cars,3);
        System.out.println(carPageInfo);

        sqlSession.close();
 
   
/**
 *PageInfo对象信息  pageNum：页码  pageSize：没页条数 size：结果数 startRow：开始下标 endRow：结束下标   total：数据库表总条数  pages：共几页
 * PageInfo{pageNum=2, pageSize=3, size=3, startRow=4, endRow=6, total=9, pages=3, 
 * list=Page{count=true, pageNum=2, pageSize=3, startRow=3, endRow=6, total=9, pages=3, 
 * reasonable=false, pageSizeZero=false}
 * Car{id=9, carNum='0002', brand='凯美瑞', guidePrice=3.0, produceTime='2020-02-02', carType='新能源'},
 * Car{id=12, carNum='1111', brand='大众', guidePrice=50.0, produceTime='2022-09-09', carType='燃油车'},
 * Car{id=19, carNum='1000', brand='雪弗莱', guidePrice=10.0, produceTime='2021-11-11', carType='燃油车'}],
 * prePage=1, nextPage=3, isFirstPage=false, isLastPage=false, hasPreviousPage=true, hasNextPage=true, navigatePages=3, navigateFirstPage=1, navigateLastPage=3, navigatepageNums=[1, 2, 3]}
 */
 
  
mybatis注解
 
   
注解可以简化我们的代码，但是并不是注解永远是最好的，简单的单表增删改查可以使用注解，这样省去了写配置文件sqlMapper.xml文件。但是复杂的语句会让本就复杂的sql语句更加混乱不堪
 
   
使用方法：在定义的接口方法上加注解并加上SQL语句，详细看代码
 
  
@Delete

    @Delete("delete from powernode where id=#{id}")
    int deleteById(Long id);
  public void testDeleteById(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        int count = mapper.deleteById(7L);
        System.out.println(count);
        sqlSession.commit();
        sqlSession.close();
    }
@Insert

  @Insert("insert into powernode values(null,#{carNum}," +
            "#{brand},#{guidePrice},#{produceTime},#{carType})")
    int insert(Car car);ar);
@Test
    public  void testInsert(){
    SqlSession sqlSession = SqlSessionUtil.openSession();
    CarMapper mapper = sqlSession.getMapper(CarMapper.class);
    Car car = new Car(null,"6666","丰田霸道",32.0,"2020-11-11","燃油车");
    int count = mapper.insert(car);
    System.out.println(count);
    sqlSession.commit();
    sqlSession.close();
    }
@Update

  @Test
    public void testUpdate(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        Car car = new Car(12L,"6666","丰田霸道",32.0,"2020-11-11","燃油车");

        int count = mapper.update(car);
        System.out.println(count);
        sqlSession.commit();
        sqlSession.close();}
@Update("update powernode set car_num=#{carNum}," +
        "brand=#{brand},guide_price=#{guidePrice}," +
        "produce_time=#{produceTime}," +
        "car_type=#{carType} where id=#{id}")
    int update(Car car);
@Select
@Select("select * from powernode where id = #{id}")
//    Results当你没有配置驼峰命名时加上他  建议开启驼峰
    @Results({
            @Result(property = "id", column = "id"),
            @Result(property = "carNum", column = "car_num"),
            @Result(property = "brand", column = "brand"),
            @Result(property = "guidePrice", column = "guide_price"),
            @Result(property = "produceTime", column = "produce_time"),
            @Result(property = "carType", column = "car_type")
    })

    Car select (Long id);
   @Test
    public void testSelect(){
        SqlSession sqlSession = SqlSessionUtil.openSession();
        CarMapper mapper = sqlSession.getMapper(CarMapper.class);
        Car car = mapper.select(12L);
        System.out.println(car);
        sqlSession.close();
    }

                    
                

        
你可能感兴趣的:(mybatis,mybatis,java)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • MyBatis 详解
                        阿贾克斯的黎明
javamybatis
                        
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                                
  • Java实现的简单双向Map，支持重复Value
                                    superlxw1234
java双向map
                                    
    关键字：Java双向Map、DualHashBidiMap 
  
  
有个需求，需要根据即时修改Map结构中的Value值，比如，将Map中所有value=V1的记录改成value=V2，key保持不变。 
  
数据量比较大，遍历Map性能太差，这就需要根据Value先找到Key，然后去修改。 
  
即：既要根据Key找Value，又要根据Value
    
                                
    • 
                                
  • PL/SQL触发器基础及例子
                                    百合不是茶
oracle数据库触发器PL/SQL编程
                                    
      
触发器的简介; 
触发器的定义就是说某个条件成立的时候，触发器里面所定义的语句就会被自动的执行。因此触发器不需要人为的去调用，也不能调用。触发器和过程函数类似 过程函数必须要调用, 
  
一个表中最多只能有12个触发器类型的,触发器和过程函数相似 触发器不需要调用直接执行,


 
触发时间：指明触发器何时执行，该值可取：
before：表示在数据库动作之前触发
    
                                
    • 
                                
  • [时空与探索]穿越时空的一些问题
                                    comsci
问题
                                    
     
      我们还没有进行过任何数学形式上的证明,仅仅是一个猜想..... 
 
      这个猜想就是; 任何有质量的物体(哪怕只有一微克)都不可能穿越时空,该物体强行穿越时空的时候,物体的质量会与时空粒子产生反应,物体会变成暗物质,也就是说,任何物体穿越时空会变成暗物质..(暗物质就我的理
    
                                
    • 
                                
  • easy ui datagrid上移下移一行
                                    商人shang
js上移下移easyuidatagrid
                                    
    /**
 * 向上移动一行
 * 
 * @param dg
 * @param row
 */
function moveupRow(dg, row) {
	var datagrid = $(dg);
	var index = datagrid.datagrid("getRowIndex", row);
	if (isFirstRow(dg, row)) {
    
                                
    • 
                                
  • Java反射
                                    oloz
反射
                                    
    本人菜鸟，今天恰好有时间，写写博客，总结复习一下java反射方面的知识，欢迎大家探讨交流学习指教 
 
首先看看java中的Class 
 
package demo;

public class ClassTest {
	
	/*先了解java中的Class*/
	
	public static void main(String[] args) {
		
    //任何一个类都
    
                                
    • 
                                
  • springMVC 使用JSR-303 Validation验证
                                    杨白白
springmvc
                                    
    JSR-303是一个数据验证的规范，但是spring并没有对其进行实现，Hibernate Validator是实现了这一规范的，通过此这个实现来讲SpringMVC对JSR-303的支持。 
 JSR-303的校验是基于注解的，首先要把这些注解标记在需要验证的实体类的属性上或是其对应的get方法上。 
 
登录需要验证类 
 
public class Login {

	@NotEmpty
    
                                
    • 
                                
  • log4j
                                    香水浓
log4j
                                    
    
log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, HTML, DATABASE
#log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, ROLLINGFILE, HTML

#console
log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
log4
    
                                
    • 
                                
  • 使用ajax和history.pushState无刷新改变页面URL
                                    agevs
jquery框架Ajaxhtml5chrome
                                    
    表现 
如果你使用chrome或者firefox等浏览器访问本博客、github.com、plus.google.com等网站时，细心的你会发现页面之间的点击是通过ajax异步请求的，同时页面的URL发生了了改变。并且能够很好的支持浏览器前进和后退。 
是什么有这么强大的功能呢？ 
HTML5里引用了新的API，history.pushState和history.replaceState，就是通过
    
                                
    • 
                                
  • centos中文乱码
                                    AILIKES
centosOSssh
                                    
    一、CentOS系统访问 g.cn ，发现中文乱码。 
于是用以前的方式：yum -y install fonts-chinese 
CentOS系统安装后，还是不能显示中文字体。我使用 gedit 编辑源码，其中文注释也为乱码。     
  
      
  
后来，终于找到以下方法可以解决，需要两个中文支持的包： 
fonts-chinese-3.02-12.
    
                                
    • 
                                
  • 触发器
                                    baalwolf
触发器
                                    
    触发器(trigger)：监视某种情况，并触发某种操作。 
触发器创建语法四要素：1.监视地点(table) 2.监视事件(insert/update/delete) 3.触发时间(after/before) 4.触发事件(insert/update/delete) 
语法： 
create trigger triggerName 
after/before 
    
                                
    • 
                                
  • JS正则表达式的i m g
                                    bijian1013
JavaScript正则表达式
                                    
            g:表示全局（global)模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止。         i:表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写。         m:表示
    
                                
    • 
                                
  • HTML5模式和Hashbang模式
                                    bijian1013
JavaScriptAngularJSHashbang模式HTML5模式
                                    
            我们可以用$locationProvider来配置$location服务（可以采用注入的方式，就像AngularJS中其他所有东西一样）。这里provider的两个参数很有意思，介绍如下。 
html5Mode 
        一个布尔值，标识$location服务是否运行在HTML5模式下。 
ha
    
                                
    • 
                                
  • [Maven学习笔记六]Maven生命周期
                                    bit1129
maven
                                    
    从mvn test的输出开始说起 
  
当我们在user-core中执行mvn test时，执行的输出如下： 
  
/software/devsoftware/jdk1.7.0_55/bin/java -Dmaven.home=/software/devsoftware/apache-maven-3.2.1 -Dclassworlds.conf=/software/devs
    
                                
    • 
                                
  • 【Hadoop七】基于Yarn的Hadoop Map Reduce容错
                                    bit1129
hadoop
                                    
    运行于Yarn的Map Reduce作业，可能发生失败的点包括 
 
 Task Failure 
 Application Master Failure 
 Node Manager Failure 
 Resource Manager Failure 
 1. Task Failure 
任务执行过程中产生的异常和JVM的意外终止会汇报给Application Master。僵死的任务也会被A
    
                                
    • 
                                
  • 记一次数据推送的异常解决端口解决
                                    ronin47
记一次数据推送的异常解决
                                    
    　　 需求：从db获取数据然后推送到B 
        程序开发完成，上jboss,刚开始报了很多错，逐一解决，可最后显示连接不到数据库。机房的同事说可以ping 通。 
　　  自已画了个图，逐一排除，把linux 防火墙　和　setenforce　设置最低。 
　　　service iptables stop 

    
                                
    • 
                                
  • 巧用视错觉-UI更有趣
                                    brotherlamp
UIui视频ui教程ui自学ui资料
                                    
    我们每个人在生活中都曾感受过视错觉（optical illusion）的魅力。 
视错觉现象是双眼跟我们开的一个玩笑，而我们往往还心甘情愿地接受我们看到的假象。其实不止如此，视觉错现象的背后还有一个重要的科学原理——格式塔原理。 
格式塔原理解释了人们如何以视觉方式感觉物体，以及图像的结构，视角，大小等要素是如何影响我们的视觉的。 
在下面这篇文章中，我们首先会简单介绍一下格式塔原理中的基本概念，
    
                                
    • 
                                
  • 线段树-poj1177-N个矩形求边长（离散化+扫描线）
                                    bylijinnan
数据结构算法线段树
                                    
    package com.ljn.base;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

/**
 * POJ 1177 (线段树+离散化+扫描线)，题目链接为http://poj.org/problem?id=1177

    
                                
    • 
                                
  • HTTP协议详解
                                    chicony
http协议
                                    
    引言                                 
    
                                
    • 
                                
  • Scala设计模式
                                    chenchao051
设计模式scala
                                    
    Scala设计模式 
        
       我的话： 在国外网站上看到一篇文章，里面详细描述了很多设计模式，并且用Java及Scala两种语言描述，清晰的让我们看到各种常规的设计模式，在Scala中是如何在语言特性层面直接支持的。基于文章很nice，我利用今天的空闲时间将其翻译，希望大家能一起学习，讨论。翻译
    
                                
    • 
                                
  • 安装mysql
                                    daizj
mysql安装
                                    
    安装mysql 
  (1)删除linux上已经安装的mysql相关库信息。rpm  -e  xxxxxxx   --nodeps (强制删除) 
     执行命令rpm -qa |grep mysql 检查是否删除干净 
  (2)执行命令  rpm -i MySQL-server-5.5.31-2.el
    
                                
    • 
                                
  • HTTP状态码大全
                                    dcj3sjt126com
http状态码
                                    
    完整的 HTTP 1.1规范说明书来自于RFC 2616，你可以在http://www.talentdigger.cn/home/link.php?url=d3d3LnJmYy1lZGl0b3Iub3JnLw%3D%3D在线查阅。HTTP 1.1的状态码被标记为新特性，因为许多浏览器只支持 HTTP 1.0。你应只把状态码发送给支持 HTTP 1.1的客户端，支持协议版本可以通过调用request
    
                                
    • 
                                
  • asihttprequest上传图片
                                    dcj3sjt126com
ASIHTTPRequest
                                    
    NSURL *url =@"yourURL";
    ASIFormDataRequest*currentRequest =[ASIFormDataRequest requestWithURL:url];
    [currentRequest setPostFormat:ASIMultipartFormDataPostFormat];[currentRequest se
    
                                
    • 
                                
  • C语言中，关键字static的作用
                                    e200702084
C++cC#
                                    
    在C语言中，关键字static有三个明显的作用： 
 
1)在函数体，局部的static变量。生存期为程序的整个生命周期，（它存活多长时间）；作用域却在函数体内（它在什么地方能被访问（空间））。 
一个被声明为静态的变量在这一函数被调用过程中维持其值不变。因为它分配在静态存储区，函数调用结束后并不释放单元，但是在其它的作用域的无法访问。当再次调用这个函数时，这个局部的静态变量还存活，而且用在它的访
    
                                
    • 
                                
  • win7/8使用curl
                                    geeksun
win7
                                    
    1.  WIN7/8下要使用curl，需要下载curl-7.20.0-win64-ssl-sspi.zip和Win64OpenSSL_Light-1_0_2d.exe。  下载地址：  
http://curl.haxx.se/download.html   请选择不带SSL的版本，否则还需要安装SSL的支持包       2.  可以给Windows增加c
    
                                
    • 
                                
  • Creating a Shared Repository; Users Sharing The Repository
                                    hongtoushizi
git
                                    
    转载自：  
http://www.gitguys.com/topics/creating-a-shared-repository-users-sharing-the-repository/  Commands discussed in this section: 
 
 git init –bare 
 git clone 
 git remote 
 git pull 
 git p
    
                                
    • 
                                
  • Java实现字符串反转的8种或9种方法
                                    Josh_Persistence
异或反转递归反转二分交换反转java字符串反转栈反转
                                    
    注：对于第7种使用异或的方式来实现字符串的反转，如果不太看得明白的，可以参照另一篇博客： 
http://josh-persistence.iteye.com/blog/2205768 
  
/**
 * 
 */
package com.wsheng.aggregator.algorithm.string;

import java.util.Stack;

/**

    
                                
    • 
                                
  • 代码实现任意容量倒水问题
                                    home198979
PHP算法倒水
                                    
    形象化设计模式实战             HELLO!架构                     redis命令源码解析 
  
倒水问题：有两个杯子，一个A升，一个B升，水有无限多，现要求利用这两杯子装C
    
                                
    • 
                                
  • Druid datasource
                                    zhb8015
druid
                                    
    推荐大家使用数据库连接池 DruidDataSource. http://code.alibabatech.com/wiki/display/Druid/DruidDataSource DruidDataSource经过阿里巴巴数百个应用一年多生产环境运行验证，稳定可靠。 它最重要的特点是：监控、扩展和性能。 下载和Maven配置看这里： http
    
                                
    • 
                                
  • 两种启动监听器ApplicationListener和ServletContextListener
                                    spjich
javaspring框架
                                    
    引言:有时候需要在项目初始化的时候进行一系列工作，比如初始化一个线程池，初始化配置文件，初始化缓存等等，这时候就需要用到启动监听器，下面分别介绍一下两种常用的项目启动监听器 
  
ServletContextListener  
特点: 依赖于sevlet容器，需要配置web.xml 
使用方法: 
public class StartListener implements 
    
                                
    • 
                                
  • JavaScript Rounding Methods of the Math object
                                    何不笑
JavaScriptMath
                                    
        The next group of methods has to do with rounding decimal values into integers. Three methods — Math.ceil(),  Math.floor(), and  Math.round() — handle rounding in differen
    
                                
    •