Mybatis笔记总结

MyBatis总结

1.SSM框架介绍（Spring+SpringMVC+MyBatis）
Junit测试、log4j日志
2.MyBatis框架
1）MyBatis框架介绍（ORM对象关系映射）工作在三层架构持久层
2）MyBatis的第一个程序：student插入信息
MyBatis的主配置文件：连接数据库的四要素
映射文件：Sql语句
实现类：SqlSessionFactoryBuilder->SqlSessionFactory->SqlSession->执行sql命令
3)配置文件解析：定义别名、加载属性文件、注册映射文件、配置多个连接环境、使用日志、定义工具类
4）单表的增删改查（CURD）
5）mapper的动态代理实现增删改查
使用动态代理条件：
接口和对应映射文件在同一包下、映射文件的namespace应该是接口的全限定性类名、sqlSession.getMapper(映射文件对应接口.class)
6）动态SQL标签
、、、、sql片段
7）关联关系查询：1：n、n：1、1:1、n：m、自关联
多表连接查询、多表单独查询
的用法
8）字段名和属性名不一致：起别名、resultMap
9)延迟加载：关联关系中关联对象的多表单独查询能使用延迟加载策略
直接加载默认的
侵入式延迟加载
深度延迟加载
延迟加载的开关：主配置文件中
10)缓存
一级缓存和二级缓存（作用范围都是namespace）
一级缓存的生命周期和SQLSession相同
二级缓存的生命周期和整个应用的生命周期相同
一级缓存默认开启，无开关设置
二级缓存默认关闭，可以设置打开或关闭
二级缓存的全局开关在主配置文件中默认为true
映射文件中可以打开在该命名空间的二级缓存
在映射文件中的也可以单独设置使用不使用二级缓存，用useCache
11）MyBatis注解
注解的基本用法：@Insert、@Update、@Delete、@Select
使用动态Sql：@InsertProvider、@UpdateProvider、@DeleteProvider、@SelectProvider
生成动态sql的方法：字符串拼接（StringBuffer）、SQL类（匿名内部类）

一、第一个mybatis程序

1. 在pow文件中导入mybatis相关包

<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.21</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

2.编写mybatis核心配置文件

3.创建bean类

package com.wcc.beans;
public class Student {
     
    private Integer id;
    private String name;
    private int age;
    private double score;

    public Student() {
     
    }

    public Student(String name, int age, double score) {
     
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public Integer getId() {
     
        return id;
    }

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

    public String getName() {
     
        return name;
    }

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

    public int getAge() {
     
        return age;
    }

    public void setAge(int age) {
     
        this.age = age;
    }

    public double getScore() {
     
        return score;
    }

    public void setScore(double score) {
     
        this.score = score;
    }

    @Override
    public String toString() {
     
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

4.创建dao接口类

package com.wcc.dao;

import com.wcc.beans.Student;

public interface IStudentDao {
     
    void insertStudent(Student student);
}

5.创建dao接口实现类

package com.wcc.dao;

import com.wcc.beans.Student;
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;

/*
* 1.SqlSessionFactoryBuilder
* 2.SqlSessionFactory
* 3.SqlSession
* */
public class StudentDaoImpl implements IStudentDao {
     
    @Override
    public void insertStudent(Student student) {
     
        SqlSession session = null;
        try {
     
            //1.创建SqlSessionFactoryBulider对象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //2.加载主配置文件为InputStream类型
            InputStream is = Resources.getResourceAsStream("mybatis.xml");
            //3.由builder创建SqlSessionFactory
            SqlSessionFactory factory = builder.build(is);
            //4.由factory创建SqlSession
            session = factory.openSession();
            //5.执行插入命令
            session.insert("insertStu",student);
            //6.提交
            session.commit();
        } catch (IOException e) {
     
            e.printStackTrace();
        }finally {
     
            //7.关闭SqlSession
            if (session != null){
     
                session.close();
            }
        }
    }
}

6.创建xml映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        //namespace为dao接口层的权限定性接口名
<mapper namespace="com.wcc.dao.IStudentDao">
    //parameterType为POJO的权限定性类名
    <insert id="insertStu" parameterType="com.wcc.beans.Student">
        insert into student (name,age,score) values (#{
     name},#{
     age},#{
     score})
    </insert>
</mapper>

7.创建测试类
*/

public class MyTest
{
     
    @Test
    public void test()
    {
     
        IStudentDao studentDao = new StudentDaoImpl();
        Student student = new Student("小明",20,98.5);
        studentDao.insertStudent(student);
    }
}

二、优化dao接口实现类

1.将sqlSessionFactory定义为单例模式，提前将Sqlsession创建出来。这样dao的实现类每次增删改查就不用在创建sqlSession了。

package com.yyf.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;

public class MyBatisUtil {
     
    //因为SqlSessionFactory是重量级组件，把它定义为单例的对象
    private static SqlSessionFactory factory = null;
    public static SqlSession getSqlSession() throws IOException {
     
        if (factory == null){
     
            factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        }
        return factory.openSession();
    }
}

2.添加log2j日志，便于调试程序
1）在pow文件中引入log2j的依赖

  <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
      <version>2.12.1</version>
    </dependency>

2）java目录下编写log2j2.xml文件

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

<configuration status="OFF">
	<appenders>
		<Console name="myConsole" target="SYSTEM_OUT">
			<PatternLayout pattern="[%-5p] %m%n" />
		</Console>
	</appenders>
	
	<loggers>
		<logger name="com.yyf.dao.IStudentDao" level="trace" additivity="false">
			<appender-ref ref="myConsole" />
		</logger>
		<!--<root level="debug">
			<appender-ref ref="myConsole" />
		</root>-->
	</loggers>
</configuration>

3.给主配置文件mybatis.xml添加实体类的定义别名，并且将数剧库配置以文件形式加载进主配置文件中

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--加载jdbc属性文件-->
    <properties resource="jdbc.properties"/>

    <!--给实体类定义别名-->
    <typeAliases>
        <!--给指定的类定义指定的别名-->
        <!--<typeAlias type="com.yyf.beans.Student" alias="Stu"/>-->
        <!--给指定包下所有的类起别名，默认别名为该类的简单类名-->
        <package name="com.yyf.beans"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
        <!--<environment id="oracle">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>-->
    </environments>**加粗样式**
    <mappers>
        <!--注册映射文件-->
        <!--
            resource一般加载的是内部资源映射文件
        -->
        <!--<mapper resource="com/yyf/dao/mapper.xml"/>-->
        <!--url一般加载项目的外部资源-->
        <!--<mapper url=""/>-->
        <!--
            1.映射文件和对应的接口在同一个包下
            2.映射文件的名称必须和接口的简单类名相同
            3.映射文件中namespace的值必须是对应接口的全限定性类名
        -->
        <!--<mapper class="com.yyf.dao.IStudentDao"/>-->
        <!--
            1.映射文件和对应的接口在同一个包下
            2.映射文件的名称必须和接口的简单类名相同
            3.映射文件中namespace的值必须是对应接口的全限定性类名
            4.(可以不满足)使用动态mapper
        -->
        <package name="com.yyf.dao"/>

    </mappers>
</configuration>

4.将sqlSessionFactory定义为单例模式后的dao接口实现类

package com.yyf.dao;

import com.yyf.beans.Student;
import com.yyf.utils.MyBatisUtil;
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;
import java.util.List;
/*
* 1.SqlSessionFactoryBuilder
* 2.SqlSessionFactory
* 3.SqlSession
* */
public class StudentDaoImpl implements IStudentDao {
     
    //插入学生信息
    @Override
    public void insertStudent(Student student) {
     
        SqlSession session = null;
        try {
     
            //1.通过工具类获取SqlSession对象
            session = MyBatisUtil.getSqlSession();
            //2.执行插入命令
            session.insert("insertStu",student);
            //3.提交
            session.commit();
        } catch (IOException e) {
     
            e.printStackTrace();
        }finally {
     
            //4.关闭SqlSession
            if (session != null){
     
                session.close();
            }
        }
    }

三、使用mapper代理

使用Mapper的动态代理要求：
* 1.sqlSession.getMapper()中的参数为所要代理接口的类型
* 2.映射文件的namespace属性值必须为所代理接口的全限定性类名
* 3.映射文件中的statement的id必须和代理接口中的相应方法名称相同
1.测试类中直接调用sqlSession

package com.yyf;
import static javafx.scene.input.KeyCode.I;
import static org.junit.Assert.assertTrue;
import com.yyf.beans.Student;
import com.yyf.dao.IStudentDao;
import com.yyf.utils.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MyTest
{
     
    /**
     * 使用Mapper的动态代理要求：
     * 1.sqlSession.getMapper()中的参数为所要代理接口的类型
     * 2.映射文件的namespace属性值必须为所代理接口的全限定性类名
     * 3.映射文件中的statement的id必须和代理接口中的相应方法名称相同
     */
    SqlSession sqlSession = null;
    IStudentDao studentDao = null;
    @Before
    public void before() throws IOException {
     
        sqlSession = MyBatisUtil.getSqlSession();
        studentDao = sqlSession.getMapper(IStudentDao.class);
        System.out.print("代理："+studentDao);
    }

    @After
    public void after(){
     
        if (sqlSession != null){
     
            sqlSession.close();
        }
    }
    //学生信息插入
    @Test
    public void test01()
    {
     
        Student student = new Student("小明3",20,98.5);
        studentDao.insertStudent(student);
        sqlSession.commit();
        System.out.print("插入后："+student);
    }
  }

1.1小知识点
使用动态代理查询时，会根据所需要的结果默认调用方法selectList或selectOne方法。
如果返回结果为List,则默认调用selectList方法，否则都默认调用selectOne方法
如果需要返回map时,需要在对应的方法接口上添加注解@MapKey(value=“对应字段名”)
dao接口中代码

@MapKey(value = "name")
    Map<String,Student> selectAllStudentMap();

对应xml中代码

  <select id="selectAllStudentMap" resultType="Student">
        select id,name,age,score from student
    </select>

对应测试类中的代码

  //使用动态代理查询时，会根据需要的返回结果默认调用方法selectList或selectOne，
    //如果返回结果为List，则默认调用selectList方法，否则都默认调用selectOne方法
    //如果需要返回map时，需要在对应的接口方法上添加注解@MapKey(value="")
    //查询全部学生信息Map
    @Test
    public void test08()
    {
     
        Map<String,Student> map = studentDao.selectAllStudentMap();
        System.out.println(map.get("小明"));
    }

1.2小知识点
如果在接口层需要传入2个或者多个参数时，需要使用@Param()注解
1.3小知识点
总结：#{}中间可以填写什么内容
1.传入参数为对象时，中间写对象的属性名
2.传入参数为一个基本数据类型或String类型，中间写任意值，就是一个占位符
3.传入参数为map，map的key对应的值是基本数据类型，中间写map的key
4.传入参数为map，map的key对应的值是对象，中间写map的key.属性

List<Student> selectStudentByCondition3(@Param("name") String name,@Param("age") int age);

注解可以和参数名相同也可以不同，#{}这里填写Param中矫正的参数名

1.4常用查询语句

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yyf.dao.IStudentDao">

    <!--
        1.parameterType可以省略，如果不省略就必须写正确
        2.传入的参数是一个对象，#{
     对象的属性名}，默认调用对象属性的get方法
    -->
    <insert id="insertStudent">
        insert into student (name,age,score) values (#{
     name},#{
     age},#{
     score})
    </insert>

    <delete id="deleteStudentById">
        delete from student where id = #{
     id}
    </delete>

    <update id="updateStudent">
        update student set name=#{
     name},age=#{
     age},score=#{
     score} where id=#{
     id}
    </update>

    <insert id="insertStudentCatchId">
        insert into student (name,age,score) values (#{
     name},#{
     age},#{
     score})
        <selectKey keyColumn="id" keyProperty="id" resultType="int" order="AFTER">
            <!--select @@identity-->
            select last_insert_id()
        </selectKey>
    </insert>

    <!--
        resultType或者resultMap是必须的，并不是集合的类型，而是集合中单个元素的类型
    -->
    <select id="selectAllStudent" resultType="Student">
        select id,name,age,score from student
    </select>

    <select id="selectAllStudentMap" resultType="Student">
        select id,name,age,score from student
    </select>

    <select id="selectStudentById" resultType="Student">
        select id,name,age,score from student where id = #{
     id}
    </select>

    <select id="selectStudentByName" resultType="Student">
        select id,name,age,score from student where name like '%' #{
     name} '%'
        <!--select id,name,age,score from student where name like concat('%',#{
     name},'%')-->
        <!--select id,name,age,score from student where name like '%${value}%'-->
    </select>

    <select id="selectStudentByCondition" resultType="Student">
        select id,name,age,score from student
        where name like '%' #{
     name} '%' and age &lt; #{
     age}
    </select>

    <select id="selectStudentByCondition2" resultType="Student">
        <!--select id,name,age,score from student
        where age &gt; #{
     min} and age &lt; #{
     max}-->
        select id,name,age,score from student
        where age &gt; #{
     stu1.age} and age &lt; #{
     stu2.age}
    </select>

    <select id="selectStudentByCondition3" resultType="Student">
        select id,name,age,score from student
        where name like '%' #{
     name} '%' and age &lt; #{
     age}
    </select>
    <!--
        总结：#{
     }中间可以填写什么内容
        1.传入参数为对象时，中间写对象的属性名
        2.传入参数为一个基本数据类型或String类型，中间写任意值，就是一个占位符
        3.传入参数为map，map的key对应的值是基本数据类型，中间写map的key
        4.传入参数为map，map的key对应的值是对象，中间写map的key.属性
    -->
</mapper>

四、动态sql语句

1.if的使用

 <select id="selectStudentByIf" resultType="Student">
        select id,name,age,score from student where 1=1
        <if test="name != null and name != ''">
            and name like '%' #{
     name} '%'
        </if>
        <if test="age > 0">
            and age &lt; #{
     age}
        </if>
    </select>

注意：如果没有写1=1 会报错
2.where的使用

 <select id="selectStudentByWhere" resultType="Student">
        select id,name,age,score from student
        <where>
            <if test="name != null and name != ''">
                name like '%' #{
     name} '%'
            </if>
            <if test="age > 0">
                and age &lt; #{
     age}
            </if>
        </where>
    </select>

注意：当where和if搭配时，第一个if标签不要加and,其他的加and
3.choose when otherwise标签

 <!--
        如果输入了name查询条件，不论age有没有输入，都只按照name查询；
        如果没有输入name，只输入了age，按照age条件查询；
        如果两个都没有输入,查询不到任何结果。
    -->
    <select id="selectStudentByChoose" resultType="Student">
        select id,name,age,score from student
        <where>
            <choose>
                <when test="name != null and name != ''">
                    name like '%' #{
     name} '%'
                </when>
                <when test="age > 0">
                    age &lt; #{
     age}
                </when>
                <otherwise>
                    1!=1
                </otherwise>
            </choose>
        </where>
    </select>

4.1foreach标签 传入array数组

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

4.2foreach标签 传入list集合

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

4.3foreach标签 传入list《T》集合

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

5.sql标签 include标签 用于替换重复sql语句

<select id="selectStudentByFragment" resultType="Student">
    <include refid="xxx"/>
    <if test="list != null and list.size > 0">
        where id in
        <foreach collection="list" item="stu" open="(" close=")" separator=",">
            #{
     stu.id}
        </foreach>
    </if>
</select>

<sql id="xxx">
    select id,name,age,score from student
</sql>

6.if+set标签
修改用户信息时有时候不会修改全部，就使用set标签

<update id="modify" parameterType="User">
update user 
  <set>
      <if test="name!=null">
        name=#{
     name}
     </if>
     </set>
         where id = #{
     id}
   </update>

7.if+trim

<update id="modify" parameterType="User">
update user 
  <trim prefix="set" suffixOverrides="," suffix="where id = #{id}">
      <if test="name!=null">
        name=#{
     name}
     </if>
     </trim>
   </update>

五，关联关系查询

1.一对多(多表连接查询)
1.1实体类的定义(只展示重要部分)

//一方为主查询，关联属性定义在一方
public class Country {
     
    private Integer cid;
    private String cname;
    //关联属性
    private Set<Minister> ministers;

public class Minister {
     
    private Integer mid;
    private String mname;

1.2.dao接口

public interface ICountryDao {
     
    Country selectCountryById(int id);
}

1.3.映射文件xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yyf.dao.ICountryDao">
    <!--多表链接查询-->
    <resultMap id="countryMap" type="Country">
        <id column="cid" property="cid"/>
        <result column="cname" property="cname"/>
        <collection property="ministers" ofType="Minister">
            <id column="mid" property="mid"/>
            <result column="mname" property="mname"/>
        </collection>
    </resultMap>
    <select id="selectCountryById" resultMap="countryMap">
        select cid,cname,mid,mname from country,minister
        where cid=#{
     id} and countryId=cid
    </select>
</mapper>

注意:属性类型为集合类型时 用collection标签 类型用ofType

<collection property="ministers" ofType="Minister">

属性类型为普通类型时用association 标签 类型用javaType

 <association property="ministers" javaType="Minister"> </association>

2.一对多（多表单独查询）

<!--多表单独查询-->
<select id="selectMinisterByCountryId" resultType="Minister">
    select mid,mname from minister where countryId=#{
     cid}
</select>
<resultMap id="countryMap" type="Country">
    <id column="cid" property="cid"/>
    <result column="cname" property="cname"/>
    <collection property="ministers"
                ofType="Minister"
                select="selectMinisterByCountryId"
                column="cid">
    </collection>
</resultMap>
<select id="selectCountryById" resultMap="countryMap">
    select cid,cname from country
    where cid=#{
     id}
</select>

3.多对一(多表连接查询)
3.1实体类

//一方为主查询，关联属性定义在一方
public class Country {
     
    private Integer cid;
    private String cname;

//以多方为主查询，关联属性定义在多方
public class Minister {
     
    private Integer mid;
    private String mname;
    //关联属性,多对一关联属性是一个对象
    private Country country;

3.2dao接口

public interface IMinisterDao {
     
    Minister selectMinisterById(int id);
}

3.3映射文件xml

<resultMap id="ministerMap" type="Minister">
    <id column="mid" property="mid"/>
    <result column="mname" property="mname"/>
    <association property="country" javaType="Country">
        <id column="cid" property="cid"/>
        <result column="cname" property="cname"/>
    </association>
</resultMap>
<select id="selectMinisterById" resultMap="ministerMap">
    select mid,mname,cid,cname from minister,country
    where mid=#{
     id} and cid =countryId
</select>

4.多对一(多表单独查询)

<!--多表单独查询-->
<select id="selectCountryById" resultType="Country">
    select cid,cname from country where cid = #{
     countryId}
</select>
<resultMap id="ministerMap" type="Minister">
    <id column="mid" property="mid"/>
    <result column="mname" property="mname"/>
    <association property="country"
                 javaType="Country"
                 select="selectCountryById"
                 column="countryId"/>
</resultMap>
<select id="selectMinisterById" resultMap="ministerMap">
    select mid,mname,countryId from minister where mid = #{
     id}
</select>

5.一对一(多表连接查询)
5.1实体类

public class Husband {
     
    private Integer hid;
    private String hname;
    //关联属性
    private Wife wife;

public class Wife {
     
    private Integer wid;
    private String wname;

5.2dao接口

public interface IHusbandDao {
     
    Husband selectHusbandById(int id);
}

5.3映射文件xml

    <!--1:1多表连接查询-->
<resultMap id="husbandMap" type="Husband">
    <id column="hid" property="hid"/>
    <result column="hname" property="hname"/>
    <association property="wife" javaType="Wife">
        <id column="wid" property="wid"/>
        <result column="wname" property="wname"/>
    </association>
</resultMap>
<select id="selectHusbandById" resultMap="husbandMap">
    select hid,hname,wid,wname from husband,wife
    where hid = #{
     id} and wid = wifeId
</select>

6.一对一(多表单独查询)

    <!--1:1多表单独查询-->
<select id="selectWifeById" resultType="Wife">
    select wid,wname from wife where wid = #{
     wifeId}
</select>
<resultMap id="husbandMap" type="Husband">
    <id column="hid" property="hid"/>
    <result column="hname" property="hname"/>
    <association property="wife"
                 javaType="Wife"
                 select="selectWifeById"
                 column="wifeId">
    </association>
</resultMap>
<select id="selectHusbandById" resultMap="husbandMap">
    select hid,hname,wifeId from husband
    where hid = #{
     id}
</select>

6.1一对一共享主键连接查询

  <!--1:1共享主键多表连接查询-->
    <resultMap id="husbandMap" type="Husband">
        <id column="hid" property="hid"/>
        <result column="hname" property="hname"/>
        <association property="wife" javaType="Wife">
            <id column="wid" property="wid"/>
            <result column="wname" property="wname"/>
        </association>
    </resultMap>
    <select id="selectHusbandById" resultMap="husbandMap">
        select hid,hname,wid,wname from husband,wife
        where hid = #{
     id} and wid = hid
    </select>

6.2一对一共享主键单独查询

  <!--1:1共享主键多表单独查询-->
    <select id="selectWifeById" resultType="Wife">
        select wid,wname from wife where wid = #{
     wifeId}
    </select>
    <resultMap id="husbandMap" type="Husband">
        <id column="hid" property="hid"/>
        <result column="hname" property="hname"/>
        <association property="wife"
                     javaType="Wife"
                     select="selectWifeById"
                     column="hid">
        </association>
    </resultMap>
    <select id="selectHusbandById" resultMap="husbandMap">
        select hid,hname from husband
        where hid = #{
     id}
    </select>

7.自关联一对多（多表连接）
7.1.1实体类

//作为一方
public class Newslabel {
     
    private Integer id;
    private String name;
    //关联属性
    private Set<Newslabel> children;

7.1.2dao接口

public interface INewslabelDao {
     
    Newslabel selectNewslabelById(int id);
}

7.1.3映射文件xml

<!--自关联1：n的多表连接查询,查询栏目及其子栏目的信息（不能查到其孙栏目信息）-->
<resultMap id="newslabelMap" type="Newslabel">
    <id column="ptid" property="id"/>
    <result column="ptname" property="name"/>
    <collection property="children" ofType="Newslabel">
        <id column="cdid" property="id"/>
        <result column="cdname" property="name"/>
    </collection>
</resultMap>
<select id="selectNewslabelById" resultMap="newslabelMap">
    select pt.id ptid,pt.name ptname,cd.id cdid,cd.name cdname
    from newslabel pt,newslabel cd
    where pt.id=#{
     id} and cd.pid=pt.id
</select>

7.1自关联一对多（多表单独）

    <!--自关联1：n的多表单独查询,查询栏目及其子孙栏目的信息-->
<select id="selectNewslabelByParent" resultMap="newslabelMap">
    select id,name from newslabel where pid = #{
     id}
</select>
<resultMap id="newslabelMap" type="Newslabel">
    <id column="id" property="id"/>
    <result column="name" property="name"/>
    <collection property="children"
                ofType="Newslabel"
                select="selectNewslabelByParent"
                column="id"/>
</resultMap>
<select id="selectNewslabelById" resultMap="newslabelMap">
    select id,name from newslabel
    where id = #{
     id}
</select>

7.3自关联一对多（多表单独查询栏目的子孙栏目）

<!--自关联1：n的多表单独查询,查询栏目的子孙栏目的信息-->
<select id="selectNewslabelByParent" resultMap="newslabelMap">
    select id,name from newslabel where pid = #{
     id}
</select>
<resultMap id="newslabelMap" type="Newslabel">
    <id column="id" property="id"/>
    <result column="name" property="name"/>
    <collection property="children"
                ofType="Newslabel"
                select="selectNewslabelByParent"
                column="id"/>
</resultMap>

7.4自关联一对多（多表单独查询栏目及其父辈栏目）

    <!--自关联1：n的多表单独查询,查询栏目及其父辈栏目的信息-->
    <resultMap id="newslabelMap" type="Newslabel">
        <id column="id" property="id"/>
    <result column="name" property="name"/>
    <association property="parent"
                 javaType="Newslabel"
                 select="selectNewslabelById"
                 column="pid"/>
</resultMap>
    <select id="selectNewslabelById" resultMap="newslabelMap">
        select id,name,pid from newslabel
        where id = #{
     id}
    </select>

8.多对多多表连接查询
8.1实体类

//以student为主查询
public class Student {
     
    private Integer sid;
    private String sname;
    //关联属性
    private Set<Course> courses;

public class Course {
     
    private Integer cid;
    private String cname;

8.2dao接口

public interface IStudentDao {
     
    Student selectStudentById(int id);
}

8.3映射文件xml

```java
```java
  <!--n:m多表连接查询-->
    <resultMap id="studentMap" type="Student">
        <id column="sid" property="sid"/>
        <result column="sname" property="sname"/>
        <collection property="courses" ofType="Course">
            <id column="cid" property="cid"/>
            <result column="cname" property="cname"/>
        </collection>
    </resultMap>
    <select id="selectStudentById" resultMap="studentMap">
        select sid,sname,cid,cname from student,course,middle
        where sid = #{
     id} and studentId = sid and cid = courseId
    </select>

9.多对多的多表单独查询

<!--n:m多单独接查询-->
<select id="selectCourseById" resultType="Course">
    select cid,cname from course where cid = #{
     courseId}
</select>
<resultMap id="middleMap" type="Middle">
    <id column="mid" property="mid"/>
    <association property="course"
                 javaType="Course"
                 select="selectCourseById"
                 column="courseId"/>
</resultMap>
<select id="selectMiddleByStudent" resultMap="middleMap">
    select mid,studentId,courseId from middle where studentId = #{
     sid}
</select>
<resultMap id="studentMap" type="Student">
    <id column="sid" property="sid"/>
    <result column="sname" property="sname"/>
    <collection property="courses"
                ofType="Course"
                select="selectMiddleByStudent"
                column="sid"/>
</resultMap>
<select id="selectStudentById" resultMap="studentMap">
    select sid,sname from student
    where sid = #{
     id}
</select>

10.n:m多表连接+单独查询

  <!--n:m多表连接+单独查询-->
    <select id="selectCourseById" resultType="Course">
        select cid,cname from course where cid = #{
     courseId}
    </select>
    <resultMap id="studentMap" type="Student">
        <id column="sid" property="sid"/>
        <result column="sname" property="sname"/>
        <collection property="courses"
                    ofType="Course"
                    select="selectCourseById"
                    column="courseId"/>
    </resultMap>
    <select id="selectStudentById" resultMap="studentMap">
        select sid,sname,courseId from student,middle
        where sid = #{
     id} and studentId = sid
    </select>

小知识点
1.如果数剧库中的字段名和实体类中的属性名不一致
解决方案1：使用resultMap进行手动映射

<!--字段名和属性名不一致：使用resultMap手动映射-->
<resultMap id="studentMap" type="Student">
    <id column="sid" property="id"/>
    <result column="sname" property="name"/>
</resultMap>
<select id="selectStudentById" resultMap="studentMap">
    select sid,sname from student where sid = #{
     id}
</select>

解决方案2：给字段起别名，让别名和属性名相同
例:select sid id,sname name from student ( 数剧库中字段名为sid，实体类中为id)

   <!--字段名和属性名不一致：给字段起别名，让别名和属性名相同-->
    <select id="selectStudentById" resultType="Student">
        select sid id,sname name from student where sid = #{
     id}
    </select>

六，延迟加载

延迟加载只在多表单独查询时起作用


6.1延迟加载策略默认是关闭的，默认为直接加载。

6.1.1当想使用延迟加载时，可以在mybaits主配置文件中设置settings标签的lazyLoadingEnabled属性设置为ture进行打开,settings标签放置有顺序，需要要在properties标签后放置。

6.1.2打开延迟加载后，默认是深度延迟加载，当用户查询主表详情时，关联表不会被查找，只有当查找到关联表的详情后关联表才被查询。
6.2主配置文件

<?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>

    <!--加载jdbc属性文件-->
    <properties resource="jdbc.properties"/>

    <settings>
        <!--打开延迟加载的总开关，默认使用的是深度延迟加载策略-->
        <setting name="lazyLoadingEnabled" value="true"/>
//        
  //      
    </settings>

    <!--给实体类定义别名-->
    <typeAliases>
        <package name="com.yyf.beans"/>
    </typeAliases>

6.3测试类

 @Test
    public void test()
    {
     
        Country country = countryDao.selectCountryById(2);
        System.out.println("国家的名称：" + country.getCname());//关联表没有被查找
//        System.out.println("国家对应部长的个数：" + country.getMinisters().size());此时关联表才被查询。
    }

6.2.1 如果想使用侵入式延迟加载，在settings中设置aggressiveLazyLoading属性为true,同时总开关要开着，不然不起作用

<?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>

    <!--加载jdbc属性文件-->
    <properties resource="jdbc.properties"/>

    <settings>
        <!--打开延迟加载的总开关，默认使用的是深度延迟加载策略-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--总开关打开，该配置才起作用，侵入式延迟加载的开关-->
       <setting name="aggressiveLazyLoading" value="true"/>
    </settings>

    <!--给实体类定义别名-->
    <typeAliases>
        <package name="com.yyf.beans"/>
    </typeAliases>

6.3.1测试类中当查询到主表的详情时就会查找关联表

 @Test
    public void test()
    {
     
        Country country = countryDao.selectCountryById(2);
        System.out.println("国家的名称：" + country.getCname());
    }

七，缓存管理

7.1一级缓存默认开启，无法关闭
一级缓存中存放的结果不是查询结果本身，而是一个map
一级缓存底层实现是一个Map
key：hashCode + statementId + SQL语句
value:查询结果本身

7.1.1两次查询相同的student的只进行了一次对数剧库的查询
7.1.2如果使用不同的方法，即使查找的是相同的id也会对数据库进行两次查找
7.1.3不管增删改是否提交，都会清空一级缓存

 //证明：一级缓存是存在的
    @Test
    public void test01()
    {
     
        //第一次查询
        Student student = studentDao.selectStudentById(2);
        System.out.println("第一次查询：" + student);

        //第二次查询
        Student student2 = studentDao.selectStudentById(2);
        System.out.println("第二次查询：" + student2);
        //两次查询相同的student的只进行了一次对数剧库的查询
    }
    // 证明：一级缓存中存放的结果不是查询结果本身，而是一个map
    // 一级缓存底层实现是一个Map
    // key：hashCode + statementId + SQL语句
    // value:查询结果本身
    @Test
    public void test02()
    {
     
        //第一次查询
        Student student = studentDao.selectStudentById(2);
        System.out.println("第一次查询：" + student);

        //第二次查询
        Student student2 = studentDao.selectStudentById2(2);
        System.out.println("第二次查询：" + student2);
        /如果使用不同的方法，即使查找的是相同的id也会对数据库进行两次查找
    }

    // 证明：增删改操作刷新一级缓存（清空一级缓存）
    @Test
    public void test03()
    {
     
        //第一次查询
        Student student = studentDao.selectStudentById(2);
        System.out.println("第一次查询：" + student);

        // 插入一个对象
        studentDao.insertStudent(new Student());

        //第二次查询
        Student student2 = studentDao.selectStudentById(2);
        System.out.println("第二次查询：" + student2);
        //不管增删改是否提交，都会清空一级缓存
    }

7.2二级缓存
全局开关 是默认打开的，单个mapper.xml是默认关闭的，如果要使用则需要
1）对应查询的实体类实现 Serializable接口

public class Student implements Serializable {
     
    private Integer id;
    private String name;
    private int age;
    private double score;
    public Student() {
     
    }

2）mapper.xml文件中创建标签

<mapper namespace="com.yyf.dao.IStudentDao">

    <!--
        在该命名空间下打开二级缓存,
        size可以设置二级缓存的大小，
        eviction可以设置二级缓存的逐出策略，
        flushInterval可以设置二级缓存的刷新间隔
    -->
    <cache size="512" eviction="LRU" flushInterval="10000"/>

    <!--
        flushCache设置该操作是否刷新二级缓存
    -->
        <insert id="insertStudent" flushCache="false">
        insert into student (name,age,score) values (#{
     name},#{
     age},#{
     score})
    </insert>

   <!--useCache设置该查询方法是否使用缓存-->
    <select id="selectStudentById" resultType="Student" useCache="false">
        select id,name,age,score from student where id = #{
     id}
    </select>

 //证明：二级缓存是存在的
    @Test
    public void test01() throws IOException {
     
        // 第一次查询

        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        studentDao = sqlSession.getMapper(IStudentDao.class);
        Student student = studentDao.selectStudentById2(6);
        System.out.println("第一次查询：" + student);
        //关闭SqlSession，清空一级缓存
        sqlSession.close();

        SqlSession sqlSession2 = MyBatisUtil.getSqlSession();
        studentDao = sqlSession2.getMapper(IStudentDao.class);
        // 第二次查询
        Student student2 = studentDao.selectStudentById2(6);
        System.out.println("第二次查询：" + student2);
        sqlSession2.close();

        SqlSession sqlSession3 = MyBatisUtil.getSqlSession();
        studentDao = sqlSession3.getMapper(IStudentDao.class);
        // 第三次查询
        Student student3 = studentDao.selectStudentById2(6);
        System.out.println("第三次查询：" + student3);
        sqlSession3.close();
    }

    // 证明：增删改操作对二级缓存的影响
    // 增删改操作会刷新（清空）二级缓存
    // 1.刷新二级缓存到底执行了那些？？？
    // 二级缓存的底层也是Map
    // key：hashCode + statemengId + SQL语句
    // value：查询结果
    // 刷新二级缓存实际上是将二级缓存中的所有Entry对象的value置为null
    // 并没有彻底删除整个Entry对象，即key仍保留
    // 2.到底何时可以到DB执行select查询？
    // 有两种情况可以到DB执行查询
    // 1>Map中根本就不存在要查找的Entry，即key未找到
    // 2>Map中存在要查找的key，但value值为null
    // 3.增删改默认可以影响二级缓存，但也可以让其不影响二级缓存
    // 只需要在增删改的statement中添加属性flushCache="false"即可

7.3使用第三方二级缓存
7.3.1在pow文件中引入第三方缓存所需要的依赖

 <!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
    <dependency>
      <groupId>org.ehcache</groupId>
      <artifactId>ehcache</artifactId>
      <version>3.8.1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
    <dependency>
      <groupId>org.mybatis.caches</groupId>
      <artifactId>mybatis-ehcache</artifactId>
      <version>1.2.1</version>
    </dependency>

7.3.2mybatis主配置文件

<configuration>
    <!--加载jdbc属性文件-->
    <properties resource="jdbc.properties"/>
    
    <settings>
        <!--使用log4j2的日志-->
        <setting name="logImpl" value="LOG4J2"/>
        <!--二级缓存的总开关,默认是打开的-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

7.3.3mapper映射文件

<mapper namespace="com.yyf.dao.IStudentDao">

    <!--使用DHCache第三方缓存,把type类型设置为第三方缓存类型-->
    <cache type="org.mybatis.caches.ehcache.EhcacheCache">
        <property name="timeToLiveSeconds" value="1000"/>
    </cache>

    <!--
        flushCache设置该操作是否刷新二级缓存
    -->
    <insert id="insertStudent" flushCache="false">
        insert into student (name,age,score) values (#{
     name},#{
     age},#{
     score})
    </insert>
    <!--useCache设置该查询方法是否使用缓存-->
    <select id="selectStudentById" resultType="Student" useCache="false">
        select id,name,age,score from student where id = #{
     id}
    </select>

小结：

 1.二级缓存可以全局性关闭
 当前应用中所有查询均不能使用二级缓存，在mybatis的主配置文件
 2.二级缓存可以局部性关闭
 可以指定在某一个映射文件中是否使用二级缓存，在映射文件中使用
 3.二级缓存可以进行对某个查询方法是否使用二级缓存进行设置
 在对应查询标签中天健属性useCahce=“false”即可关闭

八，mybatis注解
package com.yyf.dao;
import com.yyf.beans.Student;
import org.apache.ibatis.annotations.*;
import java.util.List;
import java.util.Map;
public interface IStudentDao {
     
    // 1.注解是以@开头，首字母大写的，因为注解是类层级的成员，类层级的成员：类、接口、注解、枚举
    // 2.对注解中数组类型的属性赋值，使用{元素1,元素2,.....}
    // 3.如果数组类型的属性只有一个元素，那么{}可以省略
    // 4.若果注解只使用到了一个属性，并且属性名为value，那么这个value名称可以省略

    @Insert(value = {
     "insert into student (name,age,score) values(#{name},#{age},#{score})"})
    void insertStudent(Student student);

    @Delete(value = "delete from student where id = #{xx}")
    void deleteStudentById(int id);

    @Update("update student set name=#{name},age=#{age},score=#{score} where id = #{id}")
    void updateStudent(Student student);
  //当我们向主键是自增型的数据库表中（如 user 表）插入一条记录时，我们期望获取刚刚写入这条记录
  //的id，（因为某些场景下需要获得这个id去做其他的操作），此时我们需要使用SELECT LAST_INSERT_ID()
  //这个语句来获取插入记录后返回的自增id的值；
    @Insert("insert into student (name,age,score) values(#{name},#{age},#{score})")
    @SelectKey(statement = "select last_insert_id()",keyProperty = "id",before = false,resultType = int.class)
    void insertStudentCatchId(Student student);

    @Select("select id,name,age,score from student")
    List<Student> selectAllStudent();

    @MapKey(value = "name")
    @Select("select id,name,age,score from student")
    Map<String,Student> selectAllStudentMap();

    @Select("select id,name,age,score from student where id = #{xx}")
    Student selectStudentById(int id);

    @Select("select id,name,age,score from student where name like '%' #{name} '%'")
    List<Student> selectStudentByName(String name);

    @Select("select id,name,age,score from student where name like '%' #{name} '%' and age < #{age}")
    List<Student> selectStudentByCondition(Student student);

    //@Select("select id,name,age,score from student where age < #{max} and age > #{min}")
    @Select("select id,name,age,score from student where age < #{stu2.age} and age > #{stu1.age}")
    List<Student> selectStudentByCondition2(Map map);

    @Select("select id,name,age,score from student where name like '%' #{name} '%' and age < #{age}")
    List<Student> selectStudentByCondition3(@Param("name") String name,@Param("age") int age);

}

九，mybatis注解动态sql
 9.1dao接口
public interface IStudentDao {
     

    @InsertProvider(type = MySqlProvider.class, method = "getInsertSql")
    void insertStudent(Student student);

    @DeleteProvider(type = MySqlProvider.class, method = "getDeleteSql")
    void deleteStudentById(int id);

    //@UpdateProvider(type = MySqlProvider.class, method = "getUpdateSql")
    //@UpdateProvider(type = MySqlProvider.class, method = "getUpdateSql2")
    @UpdateProvider(type = MySqlProvider.class, method = "getUpdateSql3")
    void updateStudent(Student student);

    @InsertProvider(type = MySqlProvider.class, method = "getInsertSql")
    @SelectKey(statement = "select last_insert_id()",keyProperty = "id",before = false,resultType = int.class)
    void insertStudentCatchId(Student student);

    @SelectProvider(type = MySqlProvider.class, method = "getSelectSql")
    List<Student> selectAllStudent();

    @SelectProvider(type = MySqlProvider.class, method = "getSelectSql")
    Student selectStudentById(Integer id);

    @SelectProvider(type = MySqlProvider.class, method = "getSelectSql2")
    List<Student> selectStudentByName(String name);

    @MapKey(value = "name")
    @SelectProvider(type = MySqlProvider.class,method = "getSelectSql")
    Map<String,Student> selectAllStudentMap();

    @SelectProvider(type = MySqlProvider.class, method = "getSelectSql3")
    List<Student> selectStudentByCondition(Student student);

    @SelectProvider(type = MySqlProvider.class, method = "getSelectSql4")
    List<Student> selectStudentByCondition2(Map map);

    //@SelectProvider(type = MySqlProvider.class, method = "getSelectSql5")
    @SelectProvider(type = MySqlProvider.class, method = "getSelectSql6")
    List<Student> selectStudentByCondition3(@Param("name") String name,@Param("age") int age);

}

9.2MySqlProvider类
package com.yyf.dao;

import com.yyf.beans.Student;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.jdbc.SQL;

import java.util.Map;

/**
 * company: www.abc.com
 * Author: Administrator
 * Create Data: 2020/10/26 0026
 */
public class MySqlProvider {
     
    public String getInsertSql(){
     
        return "insert into student (name,age,score) values(#{name},#{age},#{score})";
    }

    public String getDeleteSql(){
     
        return "delete from student where id = #{id}";
    }

    public String getUpdateSql(){
     
        return "update student set name=#{name},age=#{age},score=#{score} where id = #{id}";
    }

    public String getSelectSql(Integer id){
     
        if (id != null){
     
            return "select id,name,age,score from student where id = #{id}";
        }else {
     
            return "select id,name,age,score from student";
        }
    }
    public String getSelectSql2(){
     
        return "select id,name,age,score from student where name like '%' #{name} '%'";
    }

    public String getSelectSql3(Student student){
     
        StringBuffer sql = new StringBuffer();
        sql.append("select id,name,age,score from student where 1=1");
        if (student.getName() != null && !"".equals(student.getName())){
     
            sql.append(" and name like '%' #{name} '%'");
        }
        if (student.getAge() > 0){
     
            sql.append(" and age < #{age}");
        }
        return sql.toString();
    }

    public String getSelectSql4(Map map){
     
        StringBuffer sql = new StringBuffer();
        sql.append("select id,name,age,score from student where 1=1");
        if ((Integer)map.get("min") > 0){
     
            sql.append(" and age > #{min}");
        }
        if ((Integer)map.get("max") > 0){
     
            sql.append(" and age < #{max}");
        }
        return sql.toString();
    }

    public String getSelectSql5(@Param("name") String name, @Param("age") int age){
     
        StringBuffer sql = new StringBuffer();
        sql.append("select id,name,age,score from student where 1=1");
        if (name != null && !"".equals(name)){
     
            sql.append(" and name like '%' #{name} '%'");
        }
        if (age > 0){
     
            sql.append(" and age < #{age}");
        }
        return sql.toString();
    }

    public String getSelectSql6(Map map){
     
        StringBuffer sql = new StringBuffer();
        sql.append("select id,name,age,score from student where 1=1");
        if (map.get("name") != null && !"".equals(map.get("name"))){
     
            sql.append(" and name like '%' #{name} '%'");
        }
        if ((Integer)map.get("age") > 0){
     
            sql.append(" and age < #{age}");
        }
        return sql.toString();
    }
    public String getUpdateSql2(Student student){
     
        StringBuffer sql = new StringBuffer();
        //update student set name=#{name},age=#{age},score=#{score} where id = #{id}
        sql.append("update student set id = #{id}");
        if (student.getName() != null && !"".equals(student.getName())){
     
            sql.append(",name = #{name}");
        }
        if (student.getAge() > 0){
     
            sql.append(",age = #{age}");
        }
        if (student.getScore() > 0){
     
            sql.append(",score = #{score}");
        }
        sql.append(" where id = #{id}");
        return sql.toString();
    }

    public String getUpdateSql3(final Student student){
     
        // new SQL(){}表示创建一个SQL类的子类的对象，只不过这个子类叫什么名称不知道，也没有指定
        // 所以，这种写法叫做匿名内部类
        return new SQL(){
     
            // 下面的代码在何时被执行？
            // 当当前类（SQL类的子类）的无参构造器被调用时，会自动执行这段代码
            // 在类中的{}称为实例代码块
            {
     
                this.UPDATE("student");
                this.SET("id = #{id}");
                if (student.getName() != null && !"".equals(student.getName())){
     
                    this.SET("name = #{name}");
                }
                if (student.getAge() > 0){
     
                    this.SET("age = #{age}");
                }
                if (student.getScore() > 0){
     
                    this.SET("score = #{score}");
                }
                this.WHERE("id = #{id}");
            }
        }.toString();
    }
}

9.3测试类
public class MyTest
{
     
    SqlSession sqlSession = null;
    IStudentDao studentDao = null;
    @Before
    public void before() throws IOException {
     
        sqlSession = MyBatisUtil.getSqlSession();
        studentDao = sqlSession.getMapper(IStudentDao.class);
        //System.out.print("代理："+studentDao);
    }

    @After
    public void after(){
     
        if (sqlSession != null){
     
            sqlSession.close();
        }
    }
    //学生信息插入
    @Test
    public void test01()
    {
     
        Student student = new Student("小明3",20,98.5);
        studentDao.insertStudent(student);
        sqlSession.commit();
        System.out.print("插入后："+student);
    }
    //删除学生信息按id
    @Test
    public void test02()
    {
     
        studentDao.deleteStudentById(18);
        sqlSession.commit();
    }
    //修改学生信息按id
    @Test
    public void test03()
    {
     
        Student student = new Student("小绿",0,0);
        student.setId(10);
        studentDao.updateStudent(student);
        sqlSession.commit();
    }
    //获取最新插入的学生id
    @Test
    public void test04()
    {
     
        Student student = new Student("小小1",18,88);
        studentDao.insertStudentCatchId(student);
        sqlSession.commit();
        System.out.print("插入后："+student);
    }
    //查询全部学生信息List
    @Test
    public void test05()
    {
     
        List<Student> students = studentDao.selectAllStudent();
        for (Student s:students){
     
            System.out.println(s);
        }
    }
    //按照id查询学生信息
    @Test
    public void test06()
    {
     
        Student student = studentDao.selectStudentById(6);
            System.out.println(student);
    }
    //按照name查询学生信息
    @Test
    public void test07()
    {
     
        List<Student> students = studentDao.selectStudentByName("明");
        for (Student s:students){
     
            System.out.println(s);
        }
    }
    //使用动态代理查询时，会根据需要的返回结果默认调用方法selectList或selectOne，
    //如果返回结果为List，则默认调用selectList方法，否则都默认调用selectOne方法
    //如果需要返回map时，需要在对应的接口方法上添加注解@MapKey(value="")
    //查询全部学生信息Map
    @Test
    public void test08()
    {
     
        Map<String,Student> map = studentDao.selectAllStudentMap();
        System.out.println(map.get("小明3"));
    }
    //复合条件查询学生信息
    @Test
    public void test09()
    {
     
        //Student student = new Student("明",20,-1);
        //Student student = new Student("明",0,-1);
        //Student student = new Student(null,20,-1);
        Student student = new Student(null,0,-1);
        List<Student> students = studentDao.selectStudentByCondition(student);
        for (Student s:students){
     
            System.out.println(s);
        }
    }
    //复合条件查询学生信息2
    @Test
    public void test10()
    {
     
        Map map = new HashMap();
        /*Student stu1 = new Student(null,16,-1);
        Student stu2 = new Student(null,20,-1);
        map.put("stu1",stu1);
        map.put("stu2",stu2);*/
        map.put("min",16);
        map.put("max",20);
        List<Student> students = studentDao.selectStudentByCondition2(map);
        for (Student s:students){
     
            System.out.println(s);
        }
    }

    //复合条件查询学生信息3
    @Test
    public void test11()
    {
     
        List<Student> students = studentDao.selectStudentByCondition3("明",20);
        for (Student s:students){
     
            System.out.println(s);
        }
    }
 }

完结…















 















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



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的运行

SpringBlade dict-biz/list 接口 SQL 注入漏洞
文章永久免费只为良心
oracle数据库
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta

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)同样是完成了取最大值的功能。

spring如何整合druid连接池？
惜.己
springspringjunit数据库javaidea后端xml
目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl

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

SpringCloudAlibaba—Sentinel(限流)
菜鸟爪哇
前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源

springboot+vue项目实战一-创建SpringBoot简单项目
苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一

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）等，可以满足不同的界面设计

Spring MVC 全面指南：从入门到精通的详细解析
一杯梅子酱
技术栈学习springmvcjava
引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri

Spring Boot中实现跨域请求
BABA8891
springboot后端java
在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.

WebMagic：强大的Java爬虫框架解析与实战
Aaron_945
Javajava爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的

SAX解析xml文件
小猪猪08
xml
1.创建SAXParserFactory实例
2.通过SAXParserFactory对象获取SAXParser实例
3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类
4.SAXParser实例的parse来获取文件
    public static void main(String[] args) {
//

为什么mysql里的ibdata1文件不断的增长？
brotherlamp
linuxlinux运维linux资料linux视频linux运维自学
我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。
当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。
一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是：
ibdata1存了什么？
当你启用了 i

Quartz-quartz.properties配置
eksliang
quartz
其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。
 
下面是这些默认值的解释
#-----集群的配置
org.quartz.scheduler.instanceName =

informatica session的使用
18289753290
workflowsessionlogInformatica
如果希望workflow存储最近20次的log，在session里的Config  Object设置，log  options做配置，save  session log :sessions  run  ;savesessio log for  these runs:20
session下面的source 里面有个tracing 

Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误
酷的飞上天空
scrapy
Scrapy版本0.14.4
出现问题现象：
ERROR: Error downloading <GET http://xxxxx  CRC check failed
 
解决方法
 
1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0'
 
明确表示不支持任何形式的压缩格式，避免程序的解压

java Swing小集锦
永夜-极光
java swing
1.关闭窗体弹出确认对话框
  1.1   this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE);
  1.2  
this.addWindowListener (
new WindowAdapter () {
public void windo

强制删除.svn文件夹
随便小屋
java
 
        在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除

GET和POST有什么区别？及为什么网上的多数答案都是错的。
aijuans
get post

    如果有人问你，GET和POST，有什么区别？你会如何回答？ 我的经历
     前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。
    这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G

谈谈新浪微博背后的那些算法
aoyouzi
谈谈新浪微博背后的那些算法
本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。
微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针

Connection reset 连接被重置的解决方法
百合不是茶
java字符流连接被重置
流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置
 
被重置的代码如下;
 
客户端代码;
package 通信软件服务器;
import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.O

web.xml配置详解之filter
bijian1013
javaweb.xmlfilter
一.定义
<filter>
<filter-name>encodingfilter</filter-name>
<filter-class>com.my.app.EncodingFilter</filter-class>
<init-param>
<param-name>encoding<

Heritrix
Bill_chen
多线程xml算法制造配置管理
作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。
Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资

【Zookeeper】FAQ
bit1129
zookeeper
1.脱离IDE，运行简单的Java客户端程序
#ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient 
 
1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码
2. 如果Zookeeper集群跨越多个机房，那么Leader/

The user specified as a definer ('aaa'@'localhost') does not exist
白糖_
localhost
今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist
最后找原因发现删除操作做了触发器，而触发器里面有这样一句
/*!50017 DEFINER = ''aaa@'localhost' */
 原来最初

javascript中showModelDialog刷新父页面
bozch
JavaScript刷新父页面showModalDialog
在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行：
      window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self
      在子页面使用w

编程之美-买书折扣
bylijinnan
编程之美

import java.util.Arrays;
public class BookDiscount {
/**编程之美 买书折扣
书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。
下面用动态规划实现。
哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷

关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要
chenbowen00
strutsWEB安全
因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。
下面记录下本次解决的过程以便后续
1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议，
而使用ftp协议默认会产生一个匿名用

[电力与暖气]煤炭燃烧与电力加温
comsci

      在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区.....
      不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢?
  &nbs

oracle O7_DICTIONARY_ACCESSIBILITY参数
daizj
oracle
O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL

比较全面的MySQL优化参考
dengkane
mysql
本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。
 
1、硬件层相关优化
 
1.1、CPU相关
 
在服务器的BIOS设置中，可

C语言homework2，有一个逆序打印数字的小算法
dcj3sjt126com
c
#h1#
 
0、完成课堂例子
1、将一个四位数逆序打印
1234 ==> 4321
实现方法一：
# include <stdio.h>
int main(void)
{
int i = 1234;
int one = i%10;
int two = i / 10 % 10;
int three = i / 100 % 10;


apacheBench对网站进行压力测试
dcj3sjt126com
apachebench
   ab 的全称是 ApacheBench ， 是 Apache 附带的一个小工具 ， 专门用于 HTTP Server 的 benchmark testing ， 可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。
通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。 

2种办法让HashMap线程安全
flyfoxs
javajdkjni
多线程之--2种办法让HashMap线程安全
多线程之--synchronized 和reentrantlock的优缺点
多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync)
 
 
HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全.
 


Spring Security（04）——认证简介
234390216
Spring Security认证过程
认证简介
目录
1.1     认证过程
1.2     Web应用的认证过程
1.2.1    ExceptionTranslationFilter
1.2.2    在request之间共享SecurityContext
 
1

Java 位运算
Javahuhui
java位运算
// 左移( << ) 低位补0
// 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0：
// 0000 0000 0000 0000 0000 0000 0001 1000
System.out.println(6 << 2);// 运行结果是24
// 右移( >> ) 高位补"

mysql免安装版配置
ldzyz007
mysql
1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。
2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。
3、my-large.ini是为专用于一个SQL数据

MFC和ado数据库使用时遇到的问题
你不认识的休道人
sqlC++mfc
===================================================================
第一个
===================================================================
try{
CString sql;
sql.Format("select * from p

表单重复提交Double Submits
rensanning
double
可能发生的场景：
*多次点击提交按钮
*刷新页面
*点击浏览器回退按钮
*直接访问收藏夹中的地址
*重复发送HTTP请求（Ajax）
（1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。
这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法：
http://getbootstrap.co

Java String 十大常见问题
tomcat_oracle
java正则表达式
　1.字符串比较，使用“==”还是equals()? 　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。 　　equals()判断两个字符串的值是否相等。 　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。 　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。 　
　

SpringMVC 登陆拦截器实现登陆控制
xp9802
springMVC
思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。
 
实现方法：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 








按字母分类：
ABCDEFGHIJKLMNOPQRSTUVWXYZ其他






首页 -
关于我们 -
站内搜索 -
Sitemap -
侵权投诉

版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.