第一天0206

新学了个filter函数

介绍：

这是一个数据查找的js函数，和findIndex类似，在数组中返回满足指定条件的数据

用法：

var ages = [32, 33, 16, 40];

function checkAdult(age) {
    return age >= 18;
}

function myFunction() {
    document.getElementById("demo").innerHTML = ages.filte(checkAdult);
}

// 32,33,40

filter 函数中的参数是一个回调函数，回调参数为遍历的每一项，类似forEach
filter 函数不要写成 filte（踩坑）

第二天0207

Linux基础命令

ls 查看当前目录下的所有文件，dir 表面上和ls差不多，其实dir是dos的命令，ls是linux自带的

cd 切换目录，cd / 快速回到根目录，cd .. 返回上级目录，cd ~ 切换到home目录， cd - 返回上次目录 cd www 表示切换到www目录下

pwd 查看当前的路径

clear 清空

**mkdir **创建文件夹

rmdir 删除文件夹

rm 删除命令（目录或文件/夹）

ping www.baidu.com 可以去测试网络连接

touch Text.txt 在当前目录下新建Text.txt文件

vi/vim Text.txt编译这个文件，进入一般模式

按下i可以进入输入模式，写完后按下Esc回到一般模式

在一般模式下输入**:wq可以保存并退出，不要写:q!**不保存直接离开好像，还不询问的

cat Text.txt 检查这个文件的内容

-f 忽略不存在的文件，不会出现警告(强制)

-r 递归删除目录

-i 互动，删除询问是否删除

-b: 当目标文件或目录存在时，在执行覆盖前，会为其创建一个备份。

-n: 不要覆盖任何已存在的文件或目录。

-u：当源文件比目标文件新或者目标文件不存在时，才执行移动操作。

rm -rf / 直接递归删除完不询问，等死那种

mv 移动文件或目录，或重命名

移1： mv text.txt Text 将text文件移动到Text目录下

移2： mv Text/ Texts 将Text目录放入Texts目录下，如果Texts目录不存在会将Text改名为Texts

移3： $ mv /user/xxx.qq.com/ .* 将/user/xxx.qq.com目录下的所有文件和目录移到当前目录下

**重： ** mv aaa bbb 将aaa重命名为bbb

docker

版本要求，需要centos内核版本高于3.10

uname -r 查看操作系统的发行版号

uname -a 显示系统名、节点名称、操作系统的发行版号、内核版本等等。

搭建环境

$ yum install -y yum-utils 安装yum

$ sudo yum -y install docker-ce docker-ce-cli containerd.io 下载最新版本docker

$ docker version 验证docker版本

$ sudo systemctl start docker 启动docker

$ systemctl restart docker.service 启动不了就重启

(也不知道为什么要在开头加个$我也没试过，后面我就不写$开头了)

docker run hello-docker 启动名叫hello-docker的容器

docker images 查看本地docker镜像

docker ps [OPTIONS] 显示运行中的容器（OPTIONS那不填的话）

OPTIONS： 可选指令

-a 显示所有的容器，包括未运行

还有别的命令，看起来不常用到就不写了比如-f –format -i什么的

docker rm 可以删除容器/镜像

docker的 -i -t -d

-i 以交互模式运行容器，通常和-t同时使用

-t 为容器重新分配一个伪输入终端，通常与 -i 同时使用；

-d 后台运行容器，并返回容器id

-it 组合起来，就当是就绪吧，跑容器的时候会用到好像

-p: 指定端口映射，格式为：主机(宿主)端口:容器端口 （比如mysql容器端口默认是3306，那后面就可以填3306，至于前面的宿主机端口是让个人电脑连接的时候要填的那个端口）

-P: 随机端口映射，容器内部端口随机映射到主机的端口，即随机的是宿主机的端口，

–name 为容器指定一个名称，如： –name=”mysql-01”

–dns 8.8.8.8: 指定容器使用的DNS服务器，默认和宿主一致；

docker run [OPTIONS] IMAGE [COMMAND] [ARG…]

OPTIONS可以写 - 或者 –

在这里常用的有**-d -it -p –name -P –dns **等

COMMAND 好像是写命令的比如/bin/bash，暂未知

实例：

1 2	docker run --name mynginx -d nginx:latest //使用镜像nginx:latest以后台模式(-d)启动一个容器，并将容器命名为mynginx(--name mynginx)

1
2

docker run -P -d nginx:latest
//使用镜像nginx:latest以后台模式启动一个容器，并将容器的80端口(不知道是不是这个镜像的默认就是80端口，还是-P默认是80端口)映射到宿主机的随机端口

1
2
3

docker run -p 80:80 -v /data:/data -d nginx:latest
//使用镜像nginx:latest以后台模式启动一个容器，将容器的80端口映射到宿主机的80端口，主机的目录 /data 映射到容器的 /data。
这个/-v好像是挂载

第三天0208

spring基础

resources下的beans.xml文件就可以看做是spring的容器

被spring托管后会出现小叶子的绿色标志

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:http="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tool
       http://www.springframework.org/schema/tool/spring-tool.xsd">
//上面这些就是配置文件，要用到什么就配置什么，像现在要用的其实就一点点，根本不用写这么多
<context:annotation-config/>

    <bean id="user" class="com.wzkang.pojo.demo.User">
    //这个id就是被托管进来的文件在spring容器中的id，class是指向这个文件的地址属性
    
        <property name="name" value="赫尔特雷斯"></property>
        
        //这个property中的name是你要绑定的类里面的属性，可以的话开头第一个字母写小写
        //虽然这里大写也可以用，但是有一种更简便的写法p:
        //<bean id="user" class="com.wzkang.pojo.demo.User" p:name="赫尔特雷斯"></bean>
        //实测运行结果一模一样，原理分析p:这里应该就是默认用了<property>标签
        //name就是绑定setName，set t字母后面的单词，而且会自动拆解头一个字母的大写
        //所以一定在定义set方法的时候一定要保证是大写，小写可不行
        //最后的="赫尔特雷斯"很明显就是注入属性嘛
        
        value值就给绑定的属性上值，也就是set方法注入
    </bean>
    //上面的bean标签用的是set注入，接下来看看构造器注入吧
    
    <bean id="user" class="com.wzkang.pojo.demo.User" >
        <constructor-arg value="赫尔特雷斯"/>  //最后加个/直接去掉</constructor-arg>懂的都懂
        //原理：利用这个类里头的有参构造方法，注入属性，也不用绑定属性了，有参构造都写好了
        //所以最后直接value赋值就行
        //简写方法：？？没找到不知道，c:好像不行
    </bean>
    
</beans>
//beans就是spring的容器，是用来约束别的文件的框架

其实property除了name属性，还有个ref属性，甚至可以这样p:ref=”xxx”

这个ref就是指向已经被导入引用的bean标签的id

pojo类的代码

package com.wzkang.pojo.demo;

public class User {
    public String name;
    
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}

    public User() {
    System.out.println("这是来自User的无参构造方法！");
    }

    public void show(){
        System.out.println("name="+name);
    }
    --------------------------------
    public User(String name) {
        this.name = name;
    }
    //如果是用构造注入的方法的话需要写有参构造，不需要setget与无参
}
//很普通的类

测试类的代码

public class MyTest {
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    
    //因为spring核心代码是一层层架构的，这个AplicationContext还是挺底层的所以用起来会很方便
    //这里只要知道是这样用的就行，用CPXAC类的有参构造填入beans文件，返回AC类的context来用
    //上面这个代码直接写在这挺通用的应该

    @Test
    public void test001(){
        User user = (User) context.getBean("user");
        
        //看，直接拿context的getBean方法，获取在spring容器中id叫做user的容器
        //又因为这个方法返回的是Object类所以需要强转
        //如果不想要强制转换的话，可以这样写
        //User user = context.getBean("user",User.class);
        
        user.show();
        //是不是很简单，直接拿来用
    }
}
运行结果：
这是来自User的无参构造方法！
name=赫尔特雷斯

关于autowire 自动装配功能

没错，是小写的作用在bean标签上的autowire不是注解那个大写@Autowired

这个属性有2个值

autowire=”byType”

autowire=”byName”

autowire主体使用起来就有点像ref那样，自动找到并装配，然后完成工作

先讲byType

<bean class="com.wzkang.pojo.Dog" p:name="ErHa" />
<bean id="hello" class="com.wzkang.pojo.Hello" autowire="byType" />
//通过上面的学习这两段代码应该看得懂吧，用set注入名字叫ErHa
//引入一个Dog类进入spring托管，哪怕没有id，这就是byType的魅力
//然后有个hello的容器，让我们看看内部代码

Hello.java的内部代码

package com.wzkang.pojo;

public class Hello {

    private Dog doge;

    public Dog getDog() {return doge;}

    public void setDog(Dog doge) {this.doge = doge;}

    public void Hi(){
        System.out.println(this.doge.toString());
    }
}
//没啥好看的，但是内部的Hi方法要调用隶属于Dog类的值，这下就导致spring开搞了，去弄Dog类去

Dog.java的内部代码

package com.wzkang.pojo;

import org.springframework.beans.factory.annotation.Autowired;

public class Dog {
    public String name;

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }

}
//更没啥好看的
总之就是byType的作用，可以让spring直接找Dog类，也就是那个class="xxxx.Dog"，然后在注入一下拿到外面用

import com.wzkang.pojo.Hello;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

    @Test
    public void test3(){
        Hello hello = context.getBean("hello",Hello.class);
        hello.Hi();
    }
}
运行结果：
这是来自User的无参构造方法！  //这个哪儿来？spring全局注册容器肯定有走到它身上，大概是这个原理
Dog{name='ErHa'}

最后关于byName一看就知道是和名字有关的，没错同样需要class引用Dog类，然后写个name是dog就行，千万不能是Dog、doG、dOg、doge这样，因为spring自动把set后面的大写字母给转换成小写了，讲了很多遍了。

关于@Autowired注解

其实和bean标签上的autowired差不多啦

只是写在代码类上而已，应该吧

拿之前的代码来做演示

Hello.java的内部代码

package com.wzkang.pojo;

import org.springframework.beans.factory.annotation.Autowired;

public class Hello {
    @Autowired(required = false)
    //只要这里这样写了，那么bean里就可以不用写autowire属性了
    //关于byName与byType的优先度问题
    //byType>byName，两者都会用而已，先后有优先罢了
    //required = false是什么？ |好像是可以不填3/3日回答
    //默认这个值是true，但是开了false之后就说明这个属性可以为null了，否则不能为空
    
    private Dog doge;

    public Dog getDog() {
        return doge;
    }

    public void setDog(Dog doge) {
        this.doge = doge;
    }

    public void Hi(){
        System.out.println(this.doge.toString());
    }
}

关于@Qualifier注解

这个注解主要是帮助Autowired注解在复杂的问题上做出选择

使用@Qualifier(value = “xxx”)来具体指向目标

先看beans.xml的代码

<bean id="dog1" class="com.wzkang.pojo.Dog" p:name="ErHa" />
<bean id="dog2" class="com.wzkang.pojo.Dog" p:name="HaEr" />
//你看东西这么多@Autowired哪儿懂嘛这不让@Qualifier帮忙怎么行
<bean id="hello" class="com.wzkang.pojo.Hello" />

Hello.java的内部代码

package com.wzkang.pojo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class Hello {
    @Autowired(required = false)
    @Qualifier(value = "dog2")//指定使用dog2，你看简单易懂吧，其实value = 可以去掉，注解value有优待

    private Dog doge;

    public Dog getDog() {
        return doge;
    }

    public void setDog(Dog doge) {
        this.doge = doge;
    }

    public void Hi(){
        System.out.println(this.doge.toString());
    }
}
运行结果：
Dog{name='HaEr'}
具体的MyTest.java类内部代码就不看了，也就那样上面有

关于@Component注解

扫描组件嘛，说明这个类被spring管理了，前提是spring要开放扫描

用法：在要被spring托管的那个类的上方写上就行

先看beans.xml那

1 2	<context:component-scan base-package="com.wzkang.pojo"/> //只要记住，它可以让具体位置的注解可以被spring扫描到就行

Hello.java内部代码

package com.wzkang.pojo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
//不写在这上面不行，其次要开放扫描，不然这里写了也没用
//最后这个注解就相当于在spring内写了这段代码
//<bean id="hello" class="com.wzkang.pojo.Hello" />
public class Hello {

    @Autowired(required = false)

    private Dog doge;

    public Dog getDog() {
        return doge;
    }

    public void setDog(Dog doge) {
        this.doge = doge;
    }

    public void Hi(){
        System.out.println(this.doge.toString());
    }
}

就连Dog类都用@Component被spring管理了

至于值是怎么插入进去的呢？

1
2
3

@Value("ErHa")
public String name;
//太简单粗暴了

关于@Component注解下的几个衍生注解

dao [@Repository]

service [@Service]

controller [@Controller]

其作用和@Component是一样的

只是代表放在这些这些类的这些地方而已

比如上面那个Dog类或许就应该用@Repository而不是@Component呢？

关于@Nullable注解

被该字段标记的属性可以为空，简单粗暴。

关于@Scope注解

也就是作用域

属性有singleton(默认，单例)和prototype(原型)

@Component
@Scope("singleton")
//和Component同级写在类上方
public class Hello {
    @Autowired(required = false)
    ...
}

直接看下面这个简单明了

 @Test
    public void test3(){
        Hello hello1 = context.getBean("hello",Hello.class);
        Hello hello2 = context.getBean("hello",Hello.class);
        System.out.println(hello1==hello2);
    }
处于单例模式下运行结果为true
处于原型模式下运行结果为false

说白了，默认(单例)模式下，一个人就是一个人，哪怕它又被new了一次，

他这个人也还是这个人，在原型模式下这个人才会变。

第四天0209

spring动态代理

在不改变程序逻辑的情况下增加功能，平常就直接在那个程序方法上直接加代码，这样可读性差，

也要重新编译，所以不这样搞。

下面看多余的代码

SomeService.java：

public interface SomeService {//接口负责提供方法
    public void doSome();
    public void doOther();
}

SomeServiceImpl.java：

public class SomeServiceImpl implements SomeService{
    @Override
    public void doSome() {
        System.out.println("方法的执行时间"+ new Date());//要添加的功能直接写这里会导致程序越来越臃肿
        System.out.println("执行业务方法doSome");//这里才是核心代码
        System.out.println("方法执行完毕后，提交事务");//也是多余功能
    }

    @Override
    public void doOther() {
        System.out.println("方法的执行时间"+ new Date());//同理
        System.out.println("执行业务方法doOther");//这里才是核心代码
        System.out.println("方法执行完毕后，提交事务");//同理
    }
}

怎么优化？

写个工具类

比如util包下的ServiceTools.java

看代码：

public class ServiceTools {

    public static void doLog(){
        System.out.println("非业务方法，方法的执行时间："+ new Date());
    }

    public static void doTrans(){
        System.out.println("方法执行完毕后，提交事务");
    }
}
//真的只是提供方法而已，让前面那个SomeServiceImpl类来调用
//如SomeService.doLog();...这样

但是这样优化了也不够好，因为还是有方法调用

public class SomeServiceImpl implements SomeService{
    @Override
    public void doSome() {
        ServiceTools.doLog();//就是这里和doSome没啥关系
        System.out.println("执行业务方法doSome");//这里才是核心代码
        ServiceTools.doTrans();//还有这里
    }

    @Override
    public void doOther() {...}
}

我们最终的目标是不修改service类的代码，也能够增添功能

动态代理：可以在程序执行过程中，创建代理对象。

通过代理对象执行方法，给目标类增加额外的功能（功能增强）

jdk动态代理实现步骤：

1.创建目标类，SomeServiceImpl目标类，要给它的doSome和doOther增加功能。

public class SomeServiceImpl implements SomeService{
    @Override
    public void doSome() {
//        ServiceTools.doLog();
//因为要利用invocation来弄所以就不用这个了，保证原代码的不变，这里留一条回忆
        System.out.println("执行业务方法doSome");//这里才是核心代码
    }

    @Override
    public void doOther() {
        System.out.println("执行业务方法doOther");
    }
}

2.创建InvocationHandler接口的实现类，在这个类实现给目标方法增加功能。

*重点

public class MyIncationHandler implements InvocationHandler {
    //↓目标对象,也就是目标类，在这里就是SomeServiceImpl类
    private Object target;

    public MyIncationHandler(Object target) {
        this.target = target;
        //通过构造方法传递目标类
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //通过代理对象执行方法时会调用这个invoke(),这个invoke是InvocationHandler类里必须要覆写的，不是递归哈

        Object res = null;//结果集

        ServiceTools.doLog();//增添日志功能在这呢，和前面那个sout(...)一样的

        //Method 方法类， invoke应该是反射机制里的那个,这里会用就行
        //通过Method类，实现执行目标类里面本来就应该要执行的方法，比如doSome和doOther
        res = method.invoke(target,args);//args就是要实现target目标类里面所有的方法数组

        ServiceTools.doTrans();//增添事物功能同理，目标类执行完后才执行

        return res;//返回目标方法执行结果
    }
}
//主要目的就是在不更改原目标类的代码下，增加要实现的功能

3.使用jdk中，类Proxy，创建代理对象。实现创建对象的能力。

@Test
public void test003(){
    SomeService target = new SomeServiceImpl();//出现了！是目标类
    InvocationHandler Handler = new MyIncationHandler(target);//利用这个类的构造方法传入target

    ClassLoader classloader = target.getClass().getClassLoader();//获取目标类的类加载器
    Class<?>[] interfaces = target.getClass().getInterfaces();//获取目标类调用的接口

    SomeService proxy = (SomeService) Proxy.newProxyInstance(classloader, interfaces,Handler);//最后一个参数是要实现最终功能的类的对象
    //proxy类创建了个代理对象，有点像反射里的newInstance，最后这三个参数可以简写的，但是为了方便理解我才分开来

    //通过代理对象执行方法，会调用handler中的invoke方法
    proxy.doSome();
    proxy.doOther();
}

运行结果：

调用了MyIncationHandler中的invoke方法
非业务方法，方法的执行时间：Thu Feb 10 18:50:31 CST 2022
执行业务方法doSome
方法执行完毕后，提交事务
调用了MyIncationHandler中的invoke方法
非业务方法，方法的执行时间：Thu Feb 10 18:50:31 CST 2022
执行业务方法doOther
方法执行完毕后，提交事务

其实就只是在业务方法的之前之后增添新功能罢了，讲了很多遍。

第五天02010

mybatis基础

搭建数据库

CREATE TABLE user (
id int NOT NULL AUTO_INCREMENT,
name varchar(30) DEFAULT NULL,
pwd varchar(30) DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb3;

INSERT INTO user (id,name,pwd) VALUES

(1,‘张三’,123456),

(2,‘李四’,654321),

(3,‘王五’,123321)

新建项目

创建个普通的maven项目，jdk最好还是1.8版本，很多公司还在用

不勾选√，直接next

Groupld：com.wzkang

Artifactld：Mybatis-Study

next

Project name 把-加上

下面选择项目存放路径

finish

接下来左上角File–Settings–Build,Excution.Deployment–Build Tools–Maven

如果是Bundled (Maven 3)的话就改成自己的，不然的话就存放到c盘了，这个maven是java自带的

接下来这里我删除了src目录

Mybatis-Study.iml内部代码

导入maven依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!--父工程-->
    <groupId>com.wzkang</groupId>
    <artifactId>Mybatis-Study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>mybatis-01</module>
    </modules>

    <!--导入依赖-->
    <dependencies>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>//别写错了，采坑了已经
            <version>5.1.47</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>

    </dependencies>


</project>

接下来new一个module

新建模块，不勾选直接next

Aritfactld：mybatis-01

next 记得加-

finish

弄完这些可以看到idea右边的Maven都好了

在src-main-resources下新建个mybatis-config.xml文件

其代码如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!--他们说在这里哪怕用中文注释也会报错，所以我这里的注释仅仅只是用来理解-->
<!--confoguration核心配置文件-->
<configuration>

    //environments环境+s复数也就是配置多套环境，比如这样~⑴
    <environments default="development">    
    //默认环境是development，要改别的环境就改成它的id就行
    
        <environment id="development">
            //transactionManager||事务管理，这里是用JDBC的事务管理
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>//mysql就这样写
   <property name="url" value="jdbc:mysql://47.101.139.146:3307/BSAN?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                //useSSl是安全连接，设为true
                //&amp;其实就是and，单纯的一个连接符号在xml是不可以用的，所以要转译
                //useUnicode=true是用中文编码
                //characterEncoding=UTF-8用这个编码
                //其实这个还不完整，在mysql8里还有时区问题，不然时间是乱的
                //serverTimezone=GMT这个
                <property name="username" value="BSAN"/>
                <property name="password" value="BSAN"/>
            </dataSource>
        </environment>
        
        ⑴{第二套环境，这里只是展示下可以这么用，初学者一套就行
        <environment id="test">
                ......
        </environment>
        }
        
    <mappers>
        <mapper resource="com/wzkang/dao/UserMapper.xml"></mapper>
    </mappers>
        //踩坑了，一定要写上这个让mapper在mybatis核心文件中注册！
        //mapper标签的属性参数，出了resoource还可以是class类和url绝对地址
        
    </environments>
    
</configuration>

配合mysql使用，这里用idea连接数据库

idea右边有个DataBase点进去＋号

DataBase Source-MySQL

Host：47.101.139.146 数据库地址

Port：3307 数据库端口号

User：数据库用户名

Password：数据库密码

Database：数据库名字

Url：jdbc:mysql://47.101.139.146:3307/BSAN

jdbc:mysql//是mysql特有的，如果是oracle的话是别的写法

然后就是地址：端口/数据库名字缝合

然后就连上数据库了

编写mybatis工具类

在java包下规范new文件

com.wzkang.dao(都是package)

再来个和dao同级目录的utils工具类

在此目录下new一个MybatisUtils.java

看代码：

package com.wzkang.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;
import java.io.InputStream;

//用sqlSessionFactory.openSession()方法拿SqlSession就像jdbc的Connection
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static{
        try { 
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //上面的静态代码块的内容都是官网拿下来的
        //使用Mybatis获取sqlSessionFactory对象

        //既然有了SqlSessionFactory就可以获得SqlSession的实例了。
        //SqlSession完全包含了面向数据库执行SQL命令所需的方法。
    }
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
        //编写一个工具方法专门拿SqlSession对象
    }
}

然后编写代码

实体类

package com.pojo;
//先创建pojo实体类存放的package
public class User {
    //然后依据数据库的内容写属性
    private int id;
    private String name;
    private String pwd;
    //最后就是有参无参，setget，tostring
    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

原本接下来按照jdbc是要写重复代码

但是mybatis的特点是避免了几乎所有的jdbc代码和手动设置参数以及获取结果集

所以下面的这个类就删了吧

package com.wzkang.dao;

import com.pojo.User;

import java.util.List;

public class UserDaoImpl implements UserDao{
    public List<User> getUserList() {
        return null;
    }
}

Dao接口

package com.wzkang.dao;

import com.wzkang.pojo.User;

import java.util.List;

public interface UserDao {
    List<User> getUserList();
}

接口实现类由原来的UserDaoImpl转变为一个Mapper配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
上面头文件不管他
这个文件的名字和存放地点好像是不做要求的
-->

<!--
namespace绑定一个对应的Dao接口现在也可以叫做Mapper接口
不然怎么产生交集发生关系？就是通过这个namepace来唯一定位
这样才可以让名称空间绑定那个UserDao接口
-->
<mapper namespace="com.wzkang.dao.UserDao">
    
<!--玩xml一个<就可以看出所有东西了-->
    <select id="getUserList" resultType="com.wzkang.pojo.User">
<!--
select就是查询的sql语句嘛，id是UserDao接口内的方法名字
这个查询是有结果集的，所以在标签后面用resultType(类型),或者resultMap(集合)
目前就先记这2个，至于属性值要写全限定名，初学者先写集合内的泛型，不搞什么集合先
--> 
        select * from BSAN.user//加个屁;号 踩坑了
    </select>
    //select标签内不可以有注解，不然好像也会报错！！！！！
</mapper>

接下来测试

对想要测试的方法ctrl+shift+t可以快捷生成Test测试类，直接Enter就是规范的。

最好是规范建立，在哪个地方用就建在test/java包下的哪个包下面。

UserDaoTest.java内部代码

package com.wzkang.dao;

import com.wzkang.pojo.User;
import com.wzkang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
    //先通过Mybatis获取SqlSession对象
        SqlSession sqlsession = MybatisUtils.getSqlSession();
    //通过sqlsession对象获取Mapper接口
    //这个UserMapper.xml就可以看做是jdbc中实现UserDao接口中的方法的类
        UserDao userDao = sqlsession.getMapper(UserDao.class);
       //然后就可以调方法了
        List<User> userList = userDao.getUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        sqlsession.close();
    }
}

运行结果：

User{id=1, name=’张三’, pwd=’123456’}
User{id=2, name=’李四’, pwd=’654321’}
User{id=3, name=’王五’, pwd=’123321’}

第六天02011

mybatis继承昨天的学习成果完成增删改查

关于报错问题

主要是target文件夹的test-classes-com-wzkang-dao文件夹下（好奇怪，不应该是target-classes-com-wzkang-dao这个文件夹下吗，怎么好像放哪里都行啊这个配置文件）

没有UserMapper.xml，它并不会自动将上面写好的xml配置文件复制下来，在这里需要手动复制才可以

如何解决Maven的问题？复制太麻烦了吧？

Maven特性约定大于配置，所以我们要配置resouces，防止资源导出失败的问题

这里把代码添加在了pom.xml文件中

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

  <!--maven项目的打包方式
  jar: java应用
  war: javaweb应用
  -->

总结一下：

需要一个工具类，获取SqlSession对象，怎么获取呢？

需要获取SqlSessionFactory对象，用他的openSession()方法获取SqlSession对象，怎么获取呢？

需要实例化更父级的类 xxx = new SqlSessionFactoryBuider().build(inputstream)通过这个方法传入一个流才行

inputstream = Resources.getResourceAsStream(resource)//用这个类里面的静态方法传入xml配置文件

resource = “mybatis-config.xml”

这是最基础也最要的步骤了，制作一个工具类专门获取SqlSession对象。

制作完这个再回头编写mybatis-config.xml文件。

主要就是连接数据库的基本操作。

什么注册驱动，url，username，password，然后最重要的就是在配置文件中注册 mapper了。

接下来就去写pojo的实体类吧比如User的有参无参等。

再接下来就可以去写接口了，然后写与接口有交情的UserMapper.xml。

最后写Test测试。

非要加的话可以加maven的配置。

再补上，那个什么close啊以及什么openSession之类的说是要try-catch-final这样，只是说而已。

添加个根据id找用户的功能

public interface UserDao {
    List<User> getUserList();
    User getUserById(int id);//就是它，接口上写就方法
}

下一步是要去配置文件配置刚刚写的方法

<select id="getUserById" resultType="com.wzkang.pojo.User" parameterType="int">
    select * from BSAN.user where id = #{id}
</select>//查询语句用查询标签，别的语句同理
//parameterType指定接收参数的类型是int
//resultType指定返回类型是User类
关于刚刚接口里的方法需要传递参数的问题
这里只需要用#{}就行，类似于jdbc里？的占位符，{}里头写id就可以接收叫做id的参数了

添加个插入用户的功能

public interface UserDao {
    List<User> getUserList();
    User getUserById(int id);
    int addUser(User user);//一样的道理
}

同理

<insert id="addUser" parameterType="com.wzkang.pojo.User">//接收参数类型是User用户类
    insert into BSAN.user (id,name,pwd) values(#{id},#{name},#{pwd})
    //为什么这里可以直接用id name pwd属性呢？ 因为传入对象是一个User类
</insert>

测试下：

    SqlSession sqlsession = MybatisUtils.getSqlSession();
    UserDao userDao = sqlsession.getMapper(UserDao.class);
//  以后这种东西就放外面用了
@Test
public void addUser(){

    int res = userDao.addUser(new User(4,"赵六","666666"));
    if (res>0){
        System.out.println("添加成功");
    }else System.out.println("添加失败");

    sqlsession.commit();//更改功能需要事务的提交，这里直接用这个就可以
    sqlsession.close();
}

一开始遇到了ExceptionInInitializerError报错，也不知道哪里出问题了，只知道删掉insert标签那边就可以恢复正常，一口气加上去又不行，会报错，但是只要我写一点点代码再跑一下，慢慢来又不会报错，真是玄学。

添加个修改功能

public interface UserDao {
    List<User> getUserList();
    User getUserById(int id);
    int addUser(User user);
    int updateUser(User user);//真的就套娃
}

UserMapper.xml看看

<update id="updateUser" parameterType="com.wzkang.pojo.User">
    update BSAN.user set `name` = #{name},`pwd` = #{pwd} where `id` = #{id}
    //关键词可以加`号之类的
</update>

最后

@Test
public void updateUser(){
    int res = userDao.updateUser(new User(4,"王八","111111"));
    if (res!=0){
        System.out.println("修改成功");
    }else System.out.println("修改失败");
    sqlsession.commit();
    sqlsession.close();
}

接下来是删除功能

public interface UserDao {
    List<User> getUserList();
    User getUserById(int id);
    int addUser(User user);
    int updateUser(User user);
    int deleteUser(int id);
}

1
2
3

<delete id="deleteUser" parameterType="int">
    delete from BSAN.user where `id`=#{id}
</delete>

@Test
public void deleteUser(){
    int res = userDao.deleteUser(4);
    if (res!=0){
        System.out.println("删除成功");
    }else System.out.println("删除失败");
    sqlsession.commit();
    sqlsession.close();
}

没啥好讲的。

第七天02012

mybatis-万能的map

当要传递的字段或者参数过多的时候可以考虑用map传。

1	int addUser2(Map<String ,Object> map);

<insert id="addUser2" parameterType="map">
    insert into BSAN.user (id,name,pwd) values(#{id-map},#{name-map},#{pwd-map})
    //唯一的不同点就是传递的参数名字可以是随便的，因为这是key
</insert>

@Test
public void addUser2(){
    Map<String, Object> map = new HashMap<>();
    map.put("id-map",4);//key要对应前面那个传递参数的值
    map.put("name-map","赵六");
    map.put("pwd-map","122233");

    int res = userDao.addUser2(map);
    if (res>0){
        System.out.println("添加成功");
    }else System.out.println("添加失败");

    sqlsession.commit();
    sqlsession.close();
}

当然，也可以反向用map，比如

1 2	User getUserById2(Map<String,Object> map); //后面就不写了，一样的懂的都懂

再讲个细节，如果输入类型是基本类型的话可以省略不写

1	parameterType="int">//比如把这个删了

1
2
3

<select id="getUserById" resultType="com.wzkang.pojo.User" parameterType="int">
    select * from BSAN.user where id = #{id}
</select>

还有就是为什么我的是BSAN.user?

因为我用idea连接了数据库，否则的话把名字删了，直接写表名就行

关于模糊查询的问题

正常能想到的写法是这样的

1	User getUserLike(String value);

1
2
3

<select id="getUserLike" resultType="com.wzkang.pojo.User">
    select * from BSAN.user where name like #{value}
</select>

@Test
public void getUserLike(){

    User user = userDao.getUserLike("李%");//又或者是"%李%"什么的
    System.out.println(user);

    sqlsession.close();
}

来看另一种写法

1
2
3

<select id="getUserLike" resultType="com.wzkang.pojo.User">
    select * from BSAN.user where name like "%" #{value} "%"
</select>

@Test
public void getUserLike(){

    User user = userDao.getUserLike("李");
    System.out.println(user);

    sqlsession.close();
}
//一般用这2种写法

还有种写法会发生sql注入的问题

1
2
3

<select id="getUserLike" resultType="com.wzkang.pojo.User">
    select * from BSAN.user where name like '%${value}%'
</select>

public void getUserLike(){

    User user = userDao.getUserLike("' or '1'='1");
    System.out.println(user);

    sqlsession.close();
}
//反正就是查全部，知道就行

新的轮回，第一天2/22

mybatis-配置之属性优化

新建了个大的包，叫做mybatis-02

主体上把mybatis-01上的大部分内容抄了过来，但是删减了很多东西，使之成为纯净的。

回到之前的mybatis-config.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://47.101.139.146:3307/BSAN?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="BSAN"/>
                <property name="password" value="BSAN"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/wzkang/dao/UserMapper.xml"></mapper>
    </mappers>

</configuration>

先来看有个复数s，说明可以配置多套环境，但是使用的话只能选择一套，如何切换别套？

那个

1	<environments default="development">

这个default就是选择要选择那套环境的id

1	<transactionManager type="JDBC"/>

||事务管理器，有2中选择，一个默认是JDBC，还有个是MANAGED

选择JDBC——这个配置就是直接使用了JDBC的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。

而MANAGED几乎不做什么，它从来不提价或回滚一个连接，而是让容器来管理事务的整个生命周期，默认情况下它会管理连接，但是一些容器并不希望这样，因此需要将closeConnection属性设置为false来组织它默认的关闭行为。例如：

1
2
3

<transactionManager type="MANAGED"/>
    <property name="closeConnection" value="false"/>
</transactionManager>

但是如果用spring+mybatis就没必要搞这个。面试的时候不要只说JDBC一种就行。

下面来看数据源（dataSoure）

1 2	<dataSource type="POOLED"> </dataSource>

有三种的数据源类型

type=”[UNPOOLED|POOLED|JNDI]”

翻译：【没有连接池|池子|正常连接】

先来看池的概念：用完可以回收

UNPOOLED：每次被请求时打开和关闭连接，虽然有点慢，但是对性能方面没有较高要求。

默认是POOLED，用完不会关掉，下个连进来还可以用。

只要了解概念，会搞多套环境就行。

接下来是properties文件

我在resources文件夹下新建了个db.properties文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://47.101.139.146:3307/BSAN?useSSL=false&useUnicode=true&characterEncoding=UTF-8
username=xxx
password=xxx
//怎么可能涉及隐私呢我？

主要就是编写数据库的文件

内容就是注册驱动啊，数据库地址啊，数据库账号和密码啊什么的。

重点的是引入，怎么引入呢？

有个重点，xml还是有点严格的，需要遵守规矩，其标签需要按如下顺序放：

properties——settings——typeAliases——typeHandlers——objectFactor——objectWrapperFactor——reflectorFactory——plugins——environments——databaseldProvider——mappers\

比如这样：

<configuration>
    <properties resource="db.properties"/>//自闭和
        <environments default="development">
            <xxx></xxx>
            ....

这样就引入了外部文件

resources翻译：资源

做完这步就可以便捷的导入资源了

<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>

看，还是${}占位，一样的东西。

当然还可以这样玩：

<properties resource="db.properties">
    <propertie name="username" value="xxx"></propertie>
    <propertie name="password" value="xxx"></propertie>
</properties>

下面照样用。

既然如此，衍生出个没事找事的主意，既在外部文件写上密码，又在内部propertie覆写密码

出现什么问题呢？

当然是以外部properties的导入源为准，外面对就对，外面错就错。

    <typeAliases>
<!--        <typeAlias type="com.wzkang.pojo.User" alias="user"></typeAlias>-->
        <package name="com.wzkang.pojo"/>
    </typeAliases>

两种方式，一种是typeAlias，给一个实体类取别名，别人用的时候用小名就行。

另一种方式是package，扫描包，它的默认别名就是这个类的类名的首字母小写，当然用大写也可以，但是还是要规范。

在实体类较少的时候，使用第一种方式；

如果实体类十分多，建议用第二种。

区别：第一种可以DIY别名，第二种则·不行·

当然用@Alias注解可以改别名

实例：

@Alias("hello")
public class User {
    private int id;
    private String name;
    private String pwd;

在实体类头上用mybatis包下的Alias注解

其默认value是hello，就是小名了。

注意：只有让userMapper.xml，也就是有用到hello的地方，不管别的sql语句有没有用到hello这个小名，都要用上hello，不能写之前的package的默认小名。否则报错

别名可以取_int之类的，带 _ 的都是八大基本类型，也就是映射类型就是int

不带_直接写int的话，映射类型就是Integer。

设置settings

MyBatis中极为重要的调整设置，它们会改变MyBatis的运行时行为。

就说几个可能遇见的

cacheEnabled：开启缓存。

lazyLoadingEnabled：懒加载。 //效率提高？

useGeneratedKeys：允许JDBC支持自动生成主键，需要驱动支持。如果为true，则强制使用自动生成主键，尽管一些驱动不能支持但任可正常工作。（比如Derby）//不知道啥时Derby

mapUnderscoreToCamelCase：是否开启自动驼峰命名规则（camel|case）映射，即从经典数据库列名A_COLUMN到经典Java属性名aColumn的类似映射。//大部分看不懂，总之数据库中不区分大小写，Oracle全都会转化成大写，总之最后这玩意儿好像是这样的 lastName—>last_Name ??真的吗？不知道啊

logImpl：指定MyBatis所用日志的具体实现，未指定时将自动查找。//目前为止先记住这一个？？？

映射器mappers

每一个Mapper.XML都需要在Mybatis核心配置文件中注册。

<mappers>
    <mapper resource="com/wzkang/dao/UserMapper.xml"></mapper>
</mappers>
//有的人会把dao层的UserMapper.xml文件放在resources下的mapper包里，虽然同样只要绑定到这儿来就能用，
但是用class属性的时候回not found。

用class注册

1
2
3

<mappers>
<mapper class="com.wzkang.dao.UserDaoTest"></mapper>
</mappers>

踩坑点：

1.接口和他的Mapper配置文件必须同名！

2.接口和他的Mapper配置文件必须在同一个包下！

第二天2/23

mybatis-生命周期-作用域(scope)

mybatis-config.xml配置文件

↓

开始—>SqlSessionFactoryBuilder—>SqlSessionFactory—>SqlSession—>SQL Mapper—>结束

奇思妙想记忆：在什么都没有的荒漠星球上，利用SqlSessionFactoryBuilder（工厂的建造者，FactoryBuilder是这么翻译的）构造一个基地，但是肯定需要水流的，基建嘛(暗示需要InputStream，从Resources.getResourceAsStream(“ mybatis-config.xml”)来，对应上图)，工厂地基搭建好后就只剩下SqlSessionFactory了(工厂的具体显现)，然后是利用他的openSession方法创建很多SqlSession请求(服务员)，最后迎接顾客(暗示UserDao.class接口，也就是Mapper，从这调方法)，因为顾客知识渊博，从中牟利。

SqlSessionFactoryBuilder一旦创建完工厂就不用它了，丢弃不要，所以是局部的。

* SqlSessionFactory一旦创建完就没有理由丢弃它或重新创建另一个实例，可以想象为数据库连接池。

SqlSession可以想象为连接到连接池的请求，因为不是线程安全的，所以需要用完关闭，否则资源被占用！

发行版本乱改的问题

<properties>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
</properties>
//这里改成自己需要的版本就行，放在pom.xml文件下

搞了一个小时的复制mybatis–03项目，基本就是各种错误，不要一口气复制多了，会导致鸠占鹊巢现象，很麻烦，我现在maven都多个root看的强迫症犯了，好在不影响使用，没办法明天再学，已经12.30了。

踩坑经历：改了目录名字以后，mappers里也要改！

第三天2/24

mybatis接档知识错误排查与ResultMap初用

首先是数据库字段与代码字段不匹配问题

如：

数据库的密码叫做pwd，程序的User用户类的密码叫做password，那么sql语句的*号就会以数据库的字段为主，pwd的字段不匹配导致运行结果为null，解决方案，利用pwl as password 可以暴力解决，也就是起别名就能解决方法了。

但是这样做没有意义，让我们看看下面的解决方法。

引入一个很重要的概念

ResultMap结果集

这玩意儿是mybatis中最重要最强大的元素。

现在先来看简单映射来解决字段不匹配问题

直接看代码

//先回顾下resultType返回类型，parameterType是输入类型
<select id="getUserById" resultMap="UserMap">
    //利用结果集把数据库字段映射成实体类的字段。
    //当然，这个resultMap属性指代的是id
    select * from BSAN.user where id = #{id} 
</select>

//取了id就要有对应的使用，这里的type就是resultType输出类型，user简化是扫描typeAliases的帮助
<resultMap id="UserMap" type="user">
    //column是列的意思，也就是每个数据库的字段名字，property是属性，也就是映射出来的别名
    <result column="id" property="id"></result>
    <result column="name" property="name"></result>
    <result column="pwd" property="password"></result>
    //这里实测好像只需要改动第三个pwd字段映射就行，没变化的不用管
</resultMap>

这样搞password字段不匹配问题就解决了。

但是真正复杂的是后面。

第四天2/24

settings设置的使用

首先明确表明，这个标签在mybatis-config.xml里使用，上下有级标签有先后顺序，如下

</properties>
<settings>//设置内容的集合
    <setting name="" value=""/>//单个设置的配置
</settings>
<typeAliases>

name：属性可以有很多，前面几天刚开始了解的时候是有讲的，这里先讲下日志的使用，填logImpl，需要注意大小驼峰法命名，区分大小写，不要无辜增删空格，否则会报错，因为约定大于配置。

value：这里对logImpl可以是：

默认值官方是没有设定的。

看着参数很多，这里加粗的需要掌握，别的先了解。

在mybatis中具体使用哪个日志实现，在设置中设定！

STDOUT_LOGGING是标准日志输出

ERROR警告：

log4j:WARN No appenders could be found for logger (org.apache.ibatis.logging.LogFactory).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
//出现上面这个信息，说是Log4g配置找不到，奇了怪了我用的又不是这个
//反正log4j.properties里放入下面这个配置就行

\# Global logging configuration 开发时候建议使用 debug
log4j.rootLogger=DEBUG, stdout
\# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

来看使用标准日志输出的运行结果：

Logging initialized using 'class org.apache.ibatis.logging.stdout.StdOutImpl' adapter.
//Logging 初始化使用StuOutImpl日志工厂的实现
Class not found: org.jboss.vfs.VFS
JBoss 6 VFS API is not available in this environment.
Class not found: org.jboss.vfs.VirtualFile
VFS implementation org.apache.ibatis.io.JBoss6VFS is not valid in this environment.
Using VFS adapter org.apache.ibatis.io.DefaultVFS
Find JAR URL: file:/C:/Users/Administrator/Desktop/JAVA/Mybatis-Study/mybatis-03/target/classes/com/wzkang/pojo
//然后就去读一些文件
Not a JAR: file:/C:/Users/Administrator/Desktop/JAVA/Mybatis-Study/mybatis-03/target/classes/com/wzkang/pojo
Reader entry: User.class
Listing file:/C:/Users/Administrator/Desktop/JAVA/Mybatis-Study/mybatis-03/target/classes/com/wzkang/pojo
Find JAR URL: file:/C:/Users/Administrator/Desktop/JAVA/Mybatis-Study/mybatis-03/target/classes/com/wzkang/pojo/User.class
Not a JAR: file:/C:/Users/Administrator/Desktop/JAVA/Mybatis-Study/mybatis-03/target/classes/com/wzkang/pojo/User.class
Reader entry: ����   7 ;
Checking to see if class com.wzkang.pojo.User matches criteria [is assignable to Object]
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.
PooledDataSource forcefully closed/removed all connections.

//注意，重点从这里开始，上面都是准备工作
Opening JDBC Connection
//首先，打开jdbc的连接
Created connection 116669570.
//然后创建一个connection的连接对象
//所以本质还是jdbc，搞半天只是封装起来而已
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6f43c82]
//然后是设置自动提交为false
==>  Preparing: select * from BSAN.user where id = ? 
//设置完后就是预编译sql语句
==> Parameters: 1(Integer)
//接着传参数过来
<==    Columns: id, name, pwd
//查询的列是什么
<==        Row: 1, 张三, 123456
//查询的记录是什么
<==      Total: 1
//总共有几条记录
User{id=1, name='张三', password='123456'}
//最后这个才是结果
Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@6f43c82]
Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@6f43c82]
//最后把Connection对象返回这个池子里
Returned connection 116669570 to pool.

接下来我们看LOG4J

首先需要pom.xml导入maven依赖

<dependencies>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.25</version>
    </dependency>
    //下面这个就行了好像
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

1	<setting name="logImpl" value="LOG4J"/>

然后设置使用LOG4J，注意不要打错和多余空格之类。

最后在resources新建个log4.properties文件，复制以下内容丢进去。

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

最后调用deg可以实现日志功能，但我感觉真麻烦。

反正以后要搞日志就可以用log4j来实现了，写个properties给log4j，代码直接百度复制，测试类使用的代码如下：

static Logger logger = Logger.getLogger(UserDaoTest1.class);
//是apache包下的logger，别导错了，其次括号内的参数是当前调用类的反射入口

@Test
public void test03(){
    logger.info("info状态进入了test03");
    logger.debug("debug状态进入了test03");
    logger.error("error状态进入了test03");
}

lombok偷懒神器

首先导入Maven的依赖jar包

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>RELEASE</version>
    <scope>compile</scope>
</dependency>

@Data

就包含了无参构造，get、set、toString、hashcode、equals

注意！用了@AllArgsConstructor以后，无参构造就变为了全参构造了！！！

@AllArgsConstructor

就是全参构造。

@NoArgsConstructorr

就是无参构造，@Data中写了全参构造(不管是哪儿来的)就要去补无参构造。

当然还有什么@toString，@equalsandhashcode，@GetterSetter，其实都可以被@Data替代，知道有这个东西就行了。

mybatis利用limit分页查询

1 2	List<User> getUserByLimit(Map<String,Integer> map); //接口要写上的代码，多多利用Map，这里的value类型不可以是String，亲测不行

写完接口就写Mapper的配置代码

<select id="getUserByLimit" parameterType="map" resultMap="userList">
    select * from BSAN.user limit #{startIndex},#{endIndex}
    //没什么可以注意的，xxx limit 0,2从第0个之后开始，一页出现2个元素
</select>

<resultMap id="userList" type="user">
    <result property="password" column="pwd"></result>
    //这里只要不记混column是数据库列，property是pojo属性就行
</resultMap>

最后Test测试单元代码如下：

    SqlSession sqlsession = MybatisUtils.getSqlSession();
    UserDao userDao = sqlsession.getMapper(UserDao.class);
//好，不要想着static代码块包围起来了，已经空指针异常了

@Test
public void getUserByLimit(){
    HashMap<String,Integer> map = new HashMap<>();
    map.put("startIndex",0);
    map.put("endIndex",2);//重点无非就是key的名字要对应sql预写的时候留的名字
    List<User> userList = userDao.getUserByLimit(map);
    //存在列表里头的，不用for取出来查个屁
    for (User user : userList) {
        System.out.println(user);
    }
    sqlsession.close();
    //记得别浪费资源
}

lambda匿名表达式

() -> {}

大意写法是这样没错，但这和传统函数有什么不一样的呢？

传统函数：

int add (int a,int b){
    return a + b;
}
//传统方法需要什么东西？
//需要返回类型，方法名，参数列表，方法体
//但是lambda表达式是一个匿名表达式，即没有返回类型和方法名，只有参数列表和方法体
//简化结果就是这样
(int a,int b) -> {//这个箭头可以叫做goes to
    return a + b ;
}

第五天2/25

lambda继续深造

public  class MyTest {

    interface Itfc{
        int add(int x);
    }//写一个内部接口

    @Test
    public void Test01(){

        Itfc itfc1 = (int a) -> {
            return a + 2;
        };//很规范的lambda表达式了，接口里有多个参数，这里就可以写多个参数

        System.out.println(itfc1.add(5));
    }
}

简化：

Itfc itfc1 = a ->  a + 2;
//就改这一行，实现效果和上面一样
//理由：参数列表中只有一个参数的时候可以省略(int)这样
//方法体中只需要一行的话可以省略{}，但是需要return的话则需要一并省略return

这里只探讨接口里只有一种方法的情况，有多种会报错，暂不知如何解决。

其他几种情况：

interface Itfc{
    void run();
    //无返回值，无参的情况()是一定要写的。
}
    @Test
    public void Test01(){
        Itfc itfc1 = ()-> System.out.println(666);
        itfc1.run();
        //不要忘记对象的方法使用。
    }

：：的引用

xxx:xxx说白了就是引用前面那个对象的方法

interface Itfc{
    int dataMinus(int a);
}

public static int minusTwo(int x){
    return x-2;
    //很多业务方法只需要像这样简单的使用就行，所以可以引用
}

    @Test
    public void Test01(){
        Itfc itfc1 = MyTest::minusTwo;
        //如果minusTwo方法不是static修饰的话需要把对象new出来再调用
        System.out.println(itfc1.dataMinus(5));
    }
    /*
    -----------------------------------------------
     */
//      Cal itfc1 = Main::minusTwo;你甚至可以引用隔壁类的方法
//      但是隔壁的方法是void类型的，所以类型也要换个
//      多看几条实例测试就懂了

interface Itfc{
        int dataMinus(int a);
    }

   @Test
    public void Test02(){
       Itfc qq = Main::x;
        System.out.println(qq.dataMinus(11));//运行结果121
    }
//隔壁Main的x方法：
        public static int x(int x){
        return x*x;
    }
//--------------------另一实例
    interface Itfc2{
        void run();
    }

    @Test
    public void Test03(){
        Itfc2 qq = Main::a;
        qq.run();
    }
//隔壁Main的a方法：
    public static void a(){
        System.out.println(1);
    }

由此可见，：：引用出来必须要赋一个对象，这个对象一定是高度匹配的某一接口类，而且这个接口里只能有一个方法。

：：new的使用

就是引用某个类的构造方法而已

interface DogService1 {
    Dog getDog();
    //无参构造的狗
}

interface DogService2{
    Dog getDog(String name,int age);
    //有参构造的狗
}

@Test
public void Test04(){
    //先演示规范的（老古董）lambda写法
    DogService1 dog1 = ()->{
        return new Dog();
    };
    System.out.println(dog1.getDog());

    DogService2 dog2 = (String name,int age)->{
        return new Dog(name,age);
    };
    System.out.println(dog2.getDog("小黑",2));

}
//      简化后应该是这样      -----------------
        DogService1 dog1 = Dog::new;
        DogService2 dog2 = Dog::new;
//      其他不变

下一个实例：根据年龄排序

@Test
public void Test05(){
    List<Dog> dogs =new ArrayList<>();
    dogs.add(new Dog("a",1));
    dogs.add(new Dog("b",3));
    dogs.add(new Dog("c",2));
    dogs.add(new Dog("d",0));
    dogs.add(new Dog("e",4));
    //前面先存放五条狗
    dogs.sort((o1,o2)->o1.getAge()-o2.getAge());
    //这一步是利用sort方法，里面居然可以写lambda表达式，传递两个对象，根据年龄排序。。
    //百度上搜了下，这里的sort方法是放
    //Comparator.naturalOrder()或者Comparator.reverseOrder()这两个常用的
    //xxx.natura...是根据字母顺序abc自然排序，xxx.revers...是反着来的zyx降序
    //但是它List里放的只有一个String啊，我这里放类对象了都。。
    dogs.forEach(System.out::println);
    //forEach里接收lambda表达式，先把dogs里的值遍历出来，再调用表达式
    //这里的表达式仅仅只是调用这个包下的println方法而已，即拿到一个值就打印一行
    //实在看不懂就这样
    //dogs.forEach(e -> System.out.println(e));
    //一样的，拿到就打印，中途也可以来个e+2这样的业务操作
}

@FunctionInterface注解

@FunctionalInterface
//修饰在接口身上，反正意思就是只能有一个抽象方法。
interface itfc2{
    abstract int add(int x);//abstract其实默认是灰色的，这里为了方便理解才加上

     default void a(){//默认方法，写上abstract修饰会报红
         System.out.println("a");
     }
     static void b(){//静态方法同理
         System.out.println("b");
     }
}
//有意思的是默认方法和静态方法都可以写好几个

不知道没啥用

mybatis-回到主题-注解开发

一上来把UserDaoDMapper.xml删了，还把mybatis-config.xml里的mapper配置引入也删了，这就是注解吗。。

//查询所有用户
@Select("select * from BSAN.user")
List<User> getUserList();
//根据ID查询用户
@Select("select * from BSAN.user where id=#{id}")
User getUserById(int id);
//根据分页属性查询用户
@Select("select * from BSAN.user limit #{startIndex},#{endIndex}")
List<User> getUserByLimit(Map<String,Integer> map);

这样一来就没有了Mapper.xml配置文件了

那么直接让mybatis-config.xml绑定接口，本来是绑定Mapper嘛，现在换个人绑

<mappers>
    <mapper class="com.wzkang.dao.UserDao"></mapper>
</mappers>
//还是用这个标签，测试了下只能用class绑好像

缺陷：password=null，字段又不匹配了

项目实际开发，公司可能不让用注解的，其次不好维护。