Python知识点：如何使用Elasticsearch与Elasticsearch-py进行全文检索-CFANZ编程社区

<?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"><!--work-->
        <environment id="development">
            <!--Mybatis手动提交，JDBC自动提交-->
            <transactionManager type="JDBC"/>
            <!--type="POOLED" 使用数据库链接池功能，默认创建了10个链接对象，减少频繁创建的链接对象-->
            <dataSource type="POOLED">
                <!--数据库链接配置-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/ssmdb?serverTimezone=Asia/Shanghai" />
                <property name="username" value="root" />
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

➱注意将参数修改为自己的数据库连接信息

4.创建数据库,创建表,准备数据

5.创建一个访问接口,定义方法

6.创建接口对应的映射文件，编写sql

<?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">
<!--sql映射文件  主要写sql实现-->
<!--
     useGeneratedKeys="true":返回自增主键
     keyProperty="id":类中的属性
     keyColumn="id":数据库中的列
-->
<mapper namespace="com.ffyc.mybatispro.dao.AdminDao">
                                                                   <!-- keyProperty:类中的属性  keyColumn：数据库中的列-->
    <insert id="insertAdmin" parameterType="Admin" useGeneratedKeys="true" keyColumn="id" keyProperty="id">
                              <!-- 数据库中的列名                      Admin对象中的属性-->
        insert into admin(account,password,gender) values (#{account},#{password},#{gender})</insert>

    <update id="updateAdmin" parameterType="Admin">
        update admin set account=#{account},password=#{password} where id=#{id}</update>

    <select id="findAdminById" parameterType="int" resultType="Admin">
           select * from admin where id = #{id} </select>

    <select id="login" resultType="Admin">
        select * from admin where account=#{acc} and password=#{pwd}</select>

    <select id="login1" parameterType="Admin" resultType="Admin">
        select * from admin where account=#{account} and password=#{password}</select>
<!--select count(*) from admin where id  10  -->
    <select id="findAdminCount" parameterType="int" resultType="int">
        select count(*) from admin where id <![CDATA[ < ]]> 10 </select>

    <select id="findAdmins" resultType="Admin" parameterType="string">
           select * from admin order by ${orderColumn} desc</select>

    <select id="findAdminid" resultType="java.lang.Integer">
           select id from admin where account=#{account}</select>

    <select id="findAdmins1" resultType="Admin" parameterType="string">
           select * from admin</select>


    <resultMap id="adminMap" type="Admin">
        <id column="adminid" property="id"></id>
        <result column="account" property="account"></result>
    </resultMap>
    <select id="findAdmin"  resultMap="adminMap">
        select id adminid,account from admin</select>

    <delete id="deleteAdmin" parameterType="int">
        delete from
                admin where id =#{id}</delete>

 </mapper>

创建完sql映射文件后还需要再全局配置文件中进行配置：

7.测试Mybatis

搭建补充：

1、安装一个MybatisX核心全局配置文件

2、数据库链接池

链接数据库后，每次访问数据库时都要创建一个Connection连接对象，并且用完之后关闭。一旦访问量一大，每次都要创建新的连接对象，用完关闭，比较耗时。

使用数据库链接池，在池（集合）中事先创建一些连接对象，在用户访问时，就直接从池中获取一个链接对象，用完不销毁，还回到池中。这样就减少频繁创建销毁链接对象。

参数传递

三种方式

1、单个参数

直接传递

2、多个参数

使用@Param(“id”)注解绑定

传入复杂的对象，需要使用parameterType参数进行类型定义。

Mybatis基础操作---增删改查

1、增加insert

<?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">
<!--sql映射文件  主要写sql实现-->
<!--
     useGeneratedKeys="true":返回自增主键
     keyProperty="id":类中的属性
     keyColumn="id":数据库中的列
-->
<mapper namespace="com.ffyc.mybatispro.dao.AdminDao">

                                                                   <!-- keyProperty:类中的属性  keyColumn：数据库中的列-->
    <insert id="insertAdmin" parameterType="Admin" useGeneratedKeys="true" keyColumn="id" keyProperty="id">
                              <!-- 数据库中的列名                      Admin对象中的属性-->
        insert into admin(account,password,gender) values (#{account},#{password},#{gender})
    </insert>


</mapper>

2、删除delete

<?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">
<!--sql映射文件  主要写sql实现-->
<!--
     useGeneratedKeys="true":返回自增主键
     keyProperty="id":类中的属性
     keyColumn="id":数据库中的列
-->
<mapper namespace="com.ffyc.mybatispro.dao.AdminDao">
         <delete id="deleteAdmin" parameterType="int">
    delete from
            admin where id =#{id}
         </delete>


</mapper>

3、修改update

<?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">
<!--sql映射文件  主要写sql实现-->
<!--
     useGeneratedKeys="true":返回自增主键
     keyProperty="id":类中的属性
     keyColumn="id":数据库中的列
-->
<mapper namespace="com.ffyc.mybatispro.dao.AdminDao">

         <update id="updateAdmin" parameterType="Admin">
        update admin set account=#{account},password=#{password} where id=#{id}
         </update>


</mapper>

4、查找select

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--sql映射文件  主要写sql实现-->
<!--
     useGeneratedKeys="true":返回自增主键
     keyProperty="id":类中的属性
     keyColumn="id":数据库中的列
-->
<mapper namespace="com.ffyc.mybatispro.dao.AdminDao">

          <select id="findAdmins" resultType="Admin" parameterType="string">
           select * from admin order by ${orderColumn} desc
          </select>


</mapper>

#{}和${}区别

#{ }：是占位符，是采用预编译方式向sql中传值，可以防止sql注入，如果我们往sql中传值，使用#{}，更加安全。

${ }：是当作字符串将内容直接拼接到sql语句中，一般不用于向sql中传值（给列赋值），一般用于向sql中动态的传递列名。

单元测试

单元测试就是以方法为单位进行测试。

首先需要在maven项目的pom.xml文件中导入junit组件，然后在要测试的方法上添加@Test注解标签即可。

 <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>provided</scope>
        </dependency>

数据库事务

1、简介

数据库事务是数据库的一种管理的机制，是对一次链接数据库过程的管理。保证一次操作中,执行的多条sql，要么都成功执行，要么都不执行。

提交事务，数据库才会真正的在数据库执行这一次操作中的多条sql。

public class Test3 {
    /*
        单元测试，程序员使用的测试方式，以方式为单位测试
        使用junit组件实现单元测试
     */

    //单元测试，以方法为单位，进行单元测试
    @Test
    public void insert(){
        Admin admin=new Admin();
        admin.setAccount("acc");
        admin.setPassword("125");
        admin.setGender("女");
        SqlSession sqlSession= MyBatisUtil.getSqlSession();
        AdminDao adminDao=sqlSession.getMapper(AdminDao.class);
                 adminDao.insertAdmin(admin);//保存数据后，我们需要立刻拿到这条数据在数据库的主键
                 sqlSession.commit();//提交数据库事务，当我们的程序代码执行没有任何问题时,再向数据库发送提交事务操作,数据库真正执行sql,出现异常则不提交事务
                                     // 新牌,修敌,删除完毕后,都需要手动提交事务。
                 sqlSession.close();
     }

}

关联查询

1、直接多表关联査询出我们需要的数据

public class TestStudent {

    @Test
    public void test1(){
        SqlSession sqlSession= MyBatisUtil.getSqlSession();
        StudentDao studentDao=sqlSession.getMapper(StudentDao.class);
        Student student=studentDao.findStudentById(2);
        System.out.println(student.getId());
        System.out.println(student.getName());
        System.out.println(student.getMajor().getName());
        sqlSession.close();
    }
}

<?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">
<!--sql映射文件  主要写sql实现-->
<!--
     useGeneratedKeys="true":返回自增主键
     keyProperty="id":类中的属性
     keyColumn="id":数据库中的列
-->
<mapper namespace="com.ffyc.mybatispro.dao.StudentDao">


       <!--对关联查询到的学生信息进行自定义映射封装-->
    <resultMap id="studentMap" type="Student">
        <!--column是数据库  property是属性-->
        <id column="id" property="id"></id>
        <result column="num" property="num"></result>
        <result column="name" property="name"></result>
        <result column="gender" property="gender"></result>
        <!--映射关联数据  专业名称-->
        <!--映射关联数据 首先会创建一个Major对象,然后将专业名称封装到Major对象,最后将Major对象封装到Student对象中-->
        <association property="major" javaType="Major">
            <result column="mname" property="name"></result>
        </association>
    </resultMap>

      <!--关联查询方式1: 直接多表关联査询出我们需要的数据-->
    <select id="findStudentById" resultMap="studentMap">
         select
             s.id,
             s.num,
             s.name,
             s.gender,
             m.name mname
           from student s inner join major m on m.id=s.majorid where s.id=#{id}
    </select>

</mapper>

2、嵌套查询，先查询主表(学生表)

public class TestStudent {
  @Test
    public void test3(){
        SqlSession sqlSession= MyBatisUtil.getSqlSession();
        StudentDao studentDao=sqlSession.getMapper(StudentDao.class);
        Student students=studentDao.findStudentById1(2);
        sqlSession.close();
    }
}

<?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">
<!--sql映射文件  主要写sql实现-->
<!--
     useGeneratedKeys="true":返回自增主键
     keyProperty="id":类中的属性
     keyColumn="id":数据库中的列
-->
<mapper namespace="com.ffyc.mybatispro.dao.StudentDao">
       关联查询方式2： 嵌套查询，先查询主表（学生表）-->
    <resultMap id="studentMap1" type="Student">
        <id column="id" property="id"></id>
        <result column="num" property="num"></result>
        <result column="name" property="name"></result>
        <result column="gender" property="gender"></result>
        <!--封装关联表数据-->
        <association property="major" javaType="Major" select="findMajorById" column="majorid"></association>
    </resultMap>

    <select id="findStudentById1" resultMap="studentMap1">
        select id,num,name,gender,majorid from student where id=#{id}
    </select>

    <!--嵌套查询学生关联的专业   resultType="Major"  -->
    <select id="findMajorById" resultType="Major">
        select name from major where id=#{majorid}
    </select>

</mapper>

对象映射

如果表中的类名与类中的属性名完全相同，mybatis会自动将查询结果封装到POJO对象中。

如果java中使用标准驼峰命名，数据库中使用下划线连接命名，可以开始全局设置实现自动转换。

查询单张表，自动将记录映射到对象中

多表关联查询 resultMap自定义映射。如图所示：

特殊符号处理

1、在 mybatis 中的 xml 文件，一些特殊符号需要转译：

特殊字符	转译字符
<	&It;
"	"
'	'
>	>
&	&

2、使用 <![CDATA[]]>

通过 <![CDATA[ 特殊字符 ]]> 包裹特殊字符也可以

数据缓存

什么是缓存？

缓存 (Cache)：是一种用于临时存储数据的技术，将数据临时存储在内存中。

缓存的作用：让数据离我们的执行程序更近，让程序能够快速的获取到数据，减少对数据库的访问压力。

➱ MyBatis 提供了一级缓存和二级缓存来提高数据库查询的性能。

1、mybatis一级缓存

Mybatis对缓存提供支持，但是在没有配置的默认情况下，它只开启一级缓存，一级缓存只是相对于同一个SqlSession而言。

一级缓存失效的情况：

2、mybatis二级缓存

二级缓存是SqlSessionFactory级别的,根据mapper的namespace划分区域的，相同namespace的mapper查询的数据缓存在同一个区域，如果使用mapper代理方法每个mapper的namespace都不同，此时可以理解为二级缓存区域是根据mapper划分。

要开启二级缓存

需要进行以下步骤：

在 MyBatis 全局配置文件中的<settings>标签中配置开启二级缓存，设置cacheEnabled为true（默认值就是true，也可以省略这一步）
在具体的 mapper.xml 文件中添加<cache/>标签
被缓存的 POJO（实体类）必须实现序列化接口（implements Serializable）

二级缓存的特点包括：

mapper 映射文件中的所有 select 语句将会被缓存。
mapper 映射文件中的所有 insert、update 和 delete 语句会刷新缓存。
二级缓存是以 namespace 为单位的，不同 namespace 下的操作互不影响。
如果在加入<cache>标签的前提下让个别 select 元素不使用缓存，可以使用useCache属性，设置为false。
缓存默认使用最近最少使用（LRU）算法来收回。
根据时间表，如noFlushInterval（没有刷新间隔），缓存不会以任何时间顺序来刷新。
缓存会存储列表集合或对象（无论查询方法返回什么）的 1024 个引用。
缓存会被视为是可读/可写（read/write）的缓存，意味着对象检索不是共享的，而且可以安全地被调用者修改，不干扰其他调用者或线程所做的潜在修改。

Python知识点：如何使用Elasticsearch与Elasticsearch-py进行全文检索

什么是框架？

java后端框架包括

Mybatis概述

1、背景介绍

2、mybatis介绍

Mybatis环境搭建

1.创建一个maven项目

2.导入mysql数据库驱动包

导入mybatis依赖的jar包

3.创建一个全局的mybatis配置文件