Mybatis

视频

框架的基本概念

三层架构

结构

1. 界面层：用来接收客户端的输入，调用业务逻辑层进行功能处理，返回结果给客户端，servlet就是界面层的功能
2. 业务逻辑层：用来进行整个项目的业务逻辑处理，向上为界面层提供结果，向下问数据访问层要数据。
3. 数据访问层：专门用来进行数据库的增删改查操作，向上为业务逻辑层提供数据。（Mybatis）

各层之间的调用顺序是固定的，不允许跨层访问：
界面层<--------------->业务逻辑层<----------------->数据访问层

三层架构的优点

1. 结构清晰、耦合度低、各层分工明确
2. 可维护性高、可靠性高
3. 有利于标准化
4. 开发人员可以只关注整个结构中的某一层的功能实现
5. 有利于各层逻辑的复用

框架

常用的框架：SSM

1. Spring：整个其他框架的框架，核心IOC（控制反转）和AOP（面向切面编程），由20多个模块构成，很多领域提供了很好的解决方案
2. SpringMVC:Sping家族的一员，专门用来优化控制器（Servlet），提供了极简单的数据提交，数据携带，页面跳转等功能。
3. MyBatis：是持久化层的一个框架，用来进行数据库访问的优化，专注于sql语句，极大的简化了JDBC的访问

什么是框架？

是一个半成品的软件，将所有的公共的，重复的功能解决掉，帮助程序快速高效的进行开发，它是可复用的，可扩展的。

Mybatis

主要做JDBC访问的优化

1. 创建Mybatis工程

1.1 创建Maven项目

• 添加两个resources资源文件夹，目录结构：
  

1.2 在pom.xml中添加mybatis和mysql的依赖

    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatisartifactId>
      <version>3.5.6version>
    dependency>
    <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.32version>
    dependency>

• 添加资源文件夹,拷贝文件到target

  <build>
    <resources>
      <resource>
        <directory>src/main/javadirectory>
        <includes>    
          <include>**/*.propertiesinclude>
          <include>**/*.xmlinclude>
        includes>
        <filtering>falsefiltering>
      resource>
      <resource>
        <directory>src/main/resourcesdirectory>
        <includes>    
          <include>**/*.propertiesinclude>
          <include>**/*.xmlinclude>
        includes>
        <filtering>falsefiltering>
      resource>
    resources>
  build>

1.3 IDEA中配置MySQL可视化工具

1.4 resources中添加数据库连接的配置文件

文件名：jdbc.properties

	jdbc.driverClassName=com.mysql.jdbc.Driver
	jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf8
	jdbc.username=root
	jdbc.password=root

1.5 全局配置文件SqlMapConfig.xml

全局配置

DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <properties resource="jdbc.properties">properties>

    <settings>

        <setting name="logImpl" value="STDOUT_LOGGING"/>
    settings>

    <typeAliases>
        <package name="org.example.pojo"/>
    typeAliases>

    <environments default="development">
        <environment id="development">

            <transactionManager type="JDBC">transactionManager>

            <dataSource type="POOLED">

                <property name="driver" value="${jdbc.driverClassName}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            dataSource>
        environment>
    environments>
    
    <mappers>



        <package name="org.example.mapper">package>
    mappers>
configuration>

1.6 Mybatis动态代理的7个规范（重要）

以User实体类为例

1. UsersMapper.xml文件与UsersMapper.java接口文件必须在同一目录下。
2. UsersMapper.xml文件与UsersMapper.java接口文件 文件名必须一致，后缀不管
3. UsersMapper.xml文件中标签的id值与UsersMapper.java接口文件的方法名必须一致
4. UsersMapper.xml文件中标签的parameterType属性值与UsersMapper.java接口中方法的参数类型必须一致
5. UsersMapper.xml文件中标签的resultType属性值与UsersMapper.java接口的**返回值类型（返回值为List则填写泛型的类型）**必须一致
6. UsersMapper.xml文件namespace属性值必须是UserMaper.java接口的完全限定名称
7. 在SqlMapConfing.xml文件中注册UserMaper.java接口时，class=接口的完全限定名称

1.7 创建Mapper目录

根据规范第1条：创建一个文件夹
根据规范第2条：新建同名的接口和xml文件

1.7.1 创建UsersMapper接口文件

public interface UsersMapper {
    // 获取全部数据
    List<Users> getAll();
    // 通过id获取数据
    Users getUser(Integer id);
    //更新数据
    int updataUser(Users users);
    // 按名字模糊查询
    List<Users> getUserByName(String userName);
    // 插入用户
    int insertUser(Users users);
    // 根据id删除用户
    int deleteUser(Integer id);
}

1.7.2 创建UsersMapper.xml文件

属性parameterType：传入的参数。如果传入的参数为实体类，值为实体类的驼峰命名法。如果为其他则可省略此属性。
属性resultType：返回值。返回的值为实体类的类型或实体类的List集合，值为实体类的驼峰命名法。如果为其他则可省略此属性。

注意：

1. 查询、更新、删除、插入操作的标签不同
2. 更新、删除、插入操作没有返回值属性

DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="org.example.mapper.UsersMapper">



    
    <select id="getUser" resultType="Users" parameterType="Integer"> 
        select id,username,birthday,sex,address from users where id=#{id}
    select>
    
    <select id="getAll" resultType="Users">
        select id,username,birthday,sex,address from users
    select>

  
    <update id="updataUser" parameterType="users">
        update users set username=#{userName},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}
    update>

    <select id="getUserByName" parameterType="String" resultType="Users">
        select id,username,birthday,sex,address from users where username like '%${name}%'
    select>

    <insert id="insertUser" parameterType="users">
        insert into users (username,birthday,sex,address) values (#{userName},#{birthday},#{sex},#{address})
    insert>

    <delete id="deleteUser" parameterType="Integer">
        delete from users where id=#{id}
    delete>
mapper>

1.8 测试

通过动态代理执行sql语句：

1. 获取代理对象：mapper = sqlSession.getMapper(UsersMapper.class);
2. 目标对象UsersMapper.xml实现了UsersMapper接口中的方法。
3. 使用代理对象调用目标对象实现的方法getAll()：List all = mapper.getAll();

注意： 更新、删除、插入操作需要手动提交事务

public class MyTest {
    SqlSession sqlSession;
    UsersMapper mapper;
//    日期格式化工具
    SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
//   @Before作用：在所有方法执行前调用执行
    @Before
    public void openSession() throws IOException {
//   1.  读取核心配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
//   2. 创建工厂对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
//   3. 取出sqlsession对象
        sqlSession = factory.openSession();
//   4. 获取UsersMapper.xml的代理对象
        mapper = sqlSession.getMapper(UsersMapper.class);
    }
//    @After作用：有所有方法执行完毕后调用执行
    @After
    public void closeSession(){
        sqlSession.close();
    }
//    获取所有数据
    @Test
    public void testGetAll(){
//   5. 代理对象执行目标对象实现的接口中的方法
        List<Users> all = mapper.getAll();
        System.out.println(all);
    }
//    获取id的数据
    @Test
    public void testGetUser(){
        Users user= mapper.getUser(3);
        System.out.println(user);
    }
//    更新数据
    @Test
    public void updataUser() throws ParseException {
        Users users = new Users(3,"张大明", sf.parse("2000-1-1"),"1","北京朝阳");
        int n = mapper.updataUser(users);
        sqlSession.commit();//手动提交事务
    }
    // 模糊查询
    @Test
    public void testgetUserByName(){
        List<Users> users = mapper.getUserByName("三");
    }
    // 插入数据
    @Test
    public void testInsertUser() throws ParseException {
        int n = mapper.insertUser(new Users("呵呵", sf.parse("2002-2-2"), "2", "上海陆家嘴"));
        sqlSession.commit();
    }
    //根据id删除用户
    @Test
    public void testDeleteUser(){
        int n = mapper.deleteUser(31);
        sqlSession.commit();
    }
}

1.9 #{}与${}

1.9.1 #{}：占位符

1. 如果parameterType传入的参数是普通类型则#{}里面随便写
2. 如果parameterType传入的参数是引用类型，则#{}里面就要写实体类中成员变量的名称，而且区分大小写。

1.9.2 ${}字符串拼接或字符串替换(多参数传入，参数别名)

1. 字符串拼接，一般用于模糊查询，有sql注入风险。模糊查询一律使用sql语言中concat方法和#{}拼接字符串，示例：'%${name}%'改写为：concat ('%',#{name},'%')
2. ${}最重要的作用-----字符串替换：
   下面代码实现的功能：随意指定列进行模糊查询。

// 接口文件
    // 按名字模糊查询，高级版
    List<Users> getUserByNameBest(
    		// 使用注解@Param给参数设置别名
            @Param("columnName")
            String columnName,
            @Param("columnValue")
            String columnValue);

测试代码中传入两个参数，第一个参数使用${}会替换为email字符串，第二个参数使用占位符#{}，防止sql注入。

    
    <select id="getUserByNameBest" parameterType="String" resultType="Users">
        select id,name,email,age from users where ${columnName} like concat ('%',#{columnValue},'%')
    select>

测试代码：

    // 模糊查询 高级版 指定列模糊查询
    @Test
    public void testgetUserByNameBest(){
        List<Users> users = mapper.getUserByNameBest("email","126");
    }

1.9.3. 对#{}与${}的测试

使用1.9.2中的代码

# 第一种情况
select * from users where ${columnName} like concat ('%',#{columnValue},'%')
#执行后
select * from users where email like concat ('%',?,'%')
# 可以看到#{}是占位符，${columnName}替换为字符串：email

# 第二种情况
select * from users where #{columnName} like concat ('%',${columnValue},'%')
# 执行后
select * from users where ? like concat ('%',126,'%')
# 从上面两个例子可以很明确的看出#{}与${}的作用

2. 动态sql

2.1 新增数据时返回主键id

功能：在执行完相关代码后自动返回主键的id值到入参的实体类中。

        <selectKey keyProperty="id" resultType="int" order="AFTER">
            select last_insert_id()
        selectKey>

selectKey 标签的参数详解：

1. keyProperty：主键在数据库表中的列名
2. resultType：主键的类型，可能是UUID
3. order：标签体内的代码的执行时机
4. 标签体内：要执行的sql代码
5. last_insert_id()：sql语言中的函数也是获取最后插入的记录的id

示例：：
接口的mapper.xml文件

    
    <insert id="insertUserReturnId" parameterType="users">
        <selectKey keyProperty="id" resultType="int" order="AFTER">
            select last_insert_id()
        selectKey>
        insert into users (name,email,age) values (#{name},#{email},#{age})
    insert>

测试代码

    // 插入数据,并返回主键id
    @Test
    public void testInsertUserReturnId() throws ParseException {
        Users user = new Users("张小明", "[email protected]", 3);
        int n = mapper.insertUserReturnId(user);
        sqlSession.commit();
        System.out.println(user);
    }

输出：Users{id=11, name='张小明', email='[email protected]', age=3}
结论： 新增数据，主键值自动返回给传入的实体类参数。

2.2 UUID：全球唯一字符串

java中生成UUID

    // UUID  全球唯一字符串
    @Test
    public void testUUID(){
        UUID uuid = UUID.randomUUID();
        System.out.println("uuid = " + uuid);
    }

sql中生成UUID

	select uuid()

2.3 自定义代码片段

自定义代码片段:，可以将复杂、重复的代码自定义为片断。属性id的值自定义
使用自定义的代码片段:用来引用定义的代码片断。属性refid的值为片断中属性id的值

示例：

    <sql id="allColumns">
        id,name,email,age
    sql>

    <select id="getUser" resultType="Users" parameterType="Integer">
        select <include refid="allColumns">include> from users where id=#{id}
    select>

2.4 ：实现多条件查询

功能：标签代替sql语句中的where，在标签内通过使用标签等进行条件判断，达到多条件查询的目的

注意： 入参为实体类

示例：同下面 2.5 ：条件判断

2.5 ：条件判断

功能：条件为真，则使用标签内的代码

注意：

1. 标签属性test进行条件判断，注意判断是否是空字符串时使用单引号
2. 在标签内的语句记得加and

示例：

<!--    <where> 实现全条件模糊查询-->
    <select id="getAllWhere" parameterType="users" resultType="users">
        select <include refid="allColumns"></include> from users
        <where>
            <if test="userName != null and userName != ''">
                and username like concat('%',#{userName},'%')
            </if>
            <if test="birthday != null">
                and birthday = #{birthday}
            </if>
            <if test="sex != null and sex != ''">
                and sex = #{sex}
            </if>
            <if test="address != null and address != ''">
                and address like concat('%',#{address},'%')
            </if>
        </where>
    </select>

2.6 ：更新数据

原来的更新出现的问题：

• 根据id，修改姓名，实体类中只有id和name有值，其他为null
  数据更新时如果实体类的成员变量只有部分有值其他为null，更新数据库后出现下面的情况
  

解决上述问题，则需要判断传入的对象中每个成员变量是否有值来确定要更新的列

标签的作用： 代替更新语句中的set关键字，可在标签内使用判断成员变量是否有值，来决定是否更新某列。

注意：

1. 更新操作最少要有一条数据被更新，否则会报错
2. 标签包裹的代码，记得加,号。

示例：

<!-- 动态sql，更新数据 <set>标签-->
    <update id="updataUserSet" parameterType="users">
        update users
        <set>
            <if test="userName != null and userName != ''">
                username=#{userName},
            </if>
            <if test="birthday != null">
                birthday=#{birthday},
            </if>
            <if test="sex != null and sex != ''">
                sex=#{sex},
            </if>
            <if test="address != null and address != ''">
                address=#{address},
            </if>
        </set>
        where id=#{id}
    </update>

2.7 循环遍历:条件查询、批量删除、批量更新

• 标签内的属性：

1. collection：固定值。取决于接口中方法定义的参数。常用值：list、array、map
2. item：相当于java中foreach遍历时的当前元素，值自定义
3. separator：间隔符号
4. open：标签开始前的括号
5. close：标签结束后的括号

2.7.1 与select实现批量查询

查询表中名字是王五和张三的数据，原生sql语句如下

select * from users
where username in ('王五','张三')

使用foreach标签

    <select id="getByIds" resultType="Users">
        select <include refid="allColumns">include> from users
        where username in
        
        <foreach collection="array" item="item" separator="," open="(" close=")">
            #{item}
        foreach>
    select>

通过对比可以看出

('王五','张三') 
// 等同于下面的代码
<foreach collection="array" item="item" separator="," open="(" close=")">
    #{item}
</foreach>

2.7.2 与insert实现批量新增

foreach遍历的是实体类users的list集合，所以item的值就是一个users元素，要取实体类中成员变量的值，需要使用user.username。

mapper.xml配置文件：

    <insert id="updataForeach">
        insert into users (username,birthday,sex,address) values
        <foreach collection="list" item="user" separator=",">
            (#{user.userName},#{user.birthday},#{user.sex},#{user.address})
        foreach>
    insert>

2.7.3 与update实现批量更新

注意：
要使用批量更新需要在jdbc的配置文件jdbc.properties的url后面新增代码 &allowMultiQueries=true

1. 修改jdbc的配置文件
   jdbc.properties配置文件

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true
jdbc.username=root
jdbc.password=root

2. updata与foreach配合是最特殊的一组，foreach中包的不是条件或参数类的东西，而是整个update语句，注意foreach中separator属性的值为；。

    <update id="updataForeach">
        <foreach collection="list" separator=";" item="item">
            update users
            <set>
                <if test="item.userName != null and item.userName != ''">
                    username = #{item.userName},
                if>
                <if test="item.birthday != null">
                    birthday = #{item.birthday},
                if>
                <if test="item.sex != null and item.sex != ''">
                    sex = #{item.sex},
                if>
                <if test="item.address != null and item.address != ''">
                    address = #{item.address},
                if>
            set>
                where id = #{item.id}
        foreach>
    update>

3. 多个参数

3.1 按照参数的顺序取值

在下面示例中，参数(Date begin,Date end)，对应到mapper文件中使用时，按照参数的顺序，依次取值，#{arg0}取得是第一个参数begin的值， #{arg1}取得是第二个参数的值end。无论有多少参数只需要改变#{arg顺序}中的顺序就可以

缺点： 可读性差

mapper.xml文件中代码

    <select id="getBetweenDate" resultType="users">
        select <include refid="allColumns">include>
        from users
        where birthday between #{arg0} and #{arg1}
    select>

3.2 给参数取别名

见示例：1.9.2

3.3 Map作为参数的应用

使用方法

1. 将要传入的参数，存入map的键值对
2. 在xml文件中，直接使用map键值对的key就可获取到value的值

示例中传入的map键值对是：{begin=sf.parse("2000-01-01"),end=sf.parse("2002-12-31")}
在使用中，直接通过map的key#{begin} 、 #{end}就可以获取到对应的value值

测试方法

    @Test
    public void testMapGetBEtween() throws ParseException {
        Map<String,Date> map = new HashMap<>();
        map.put("begin", sf.parse("2000-01-01"));
        map.put("end", sf.parse("2002-12-31"));
        mapper.getBetweenDateByMap(map);
    }

    <select id="getBetweenDateByMap"  resultType="users">
        select <include refid="allColumns">include>
        from users
        where birthday between #{begin} and #{end}
    select>

4. 多表查询

4.1 返回值为map

4.1.1 返回一行数据

• 作用：多表查询时，返回值没有对应的实体类，使用map作为返回类型，map中key就是列名，value就是查询到的值。

注意：xml中返回值类型为map

    <select id="getSimpleMap" resultType="map">
        select name,email
        from users
        where id = #{id}
    select>

输出map的值：{name=王五, [email protected]}

• 当列有别名时，返回的map中key的值是列的别名

    <select id="getSimpleMap" resultType="map">
        select name as n ,email as e
        from users
        where id = #{id}
    select>

输出map的值：{[email protected], n=王五}

4.1.2 返回多行数据

• 返回值类型为map，与返回实体类一样，虽然最终得到的是list集合，但是resultType属性的值还是map

<!--    返回多行数据，返回map的list集合-->
<!--        List<Map> getRowsMap();-->
    <select id="getRowsMap" resultType="map">
        select name ,email from users
    </select>

4.2 列名与实体类的成员变量名不一致

问题： 列名与实体类的成员变量名不一致，并且resultType属性的值为实体类名，执行时，代码不报错，但是返回的结果为空。

4.2.1 通过别名来解决

• 给所有列设置别名，且别名与实体类成员变量名一致

数据库中列名

实体类中成员变量名

mapper.xml中给列设置别名

4.2.2 使用map映射解决

1. 在标签内使用属性resultMap，属性值自定义
   创建映射关系，标签内id属性值为上面自定义的值，type属性值为实体类
   主键映射：
   非主键映射：

   
   
       <select id="getAllMap" resultMap="mapToColumn">
           select studentid ,studentname ,studentemail ,studentage
           from student
       select>
   
       <resultMap id="mapToColumn" type="student">
           
           <id property="id" column="studentid">id>
           
           <result property="name" column="studentname">result>
           <result property="email" column="studentemail">result>
           <result property="age" column="studentage">result>
       resultMap>
   

   4.3 一对多关联查询

   需要注意的地方很多

   1. 一对多关联查询时，select查询语句中要使用left join ，以左表为主表。客户3没有订单，如果使用inner join 关联，查询结果为null，就算客户没有订单，也应该查询到该客户的信息。
   2. 当两个表有相同的列名时，必须取别名
   3. 在xml文件中做实体类的成员变量和表中列名的映射时，列名相同的必须使用别名，不然查询的结果不正确，相同列名的结果会搞混。
   4. 使用的标签和属性就一一对应的看。

   • 数据库表
     客户表：customer
     订单表：orders，列customer_id关联customer表的id列
     
   • 实体类
     customer表的成员变量有Orders的list集合

   // 客户表
   public class Customer {
       private Integer id;
       private String name;
       private Integer age;
       // 对应的订单，一对多，一个客户可以有多个订单
       private List<Orders> ordersList;
       }
   

   // 订单表
   public class Orders {
       private Integer id;
       private String orderNumber;
       private double orderPrice;
       // 对应的客户，多对一，每个订单只对应一个客户
       private Customer cus;
   

   • mapper.xml

   
   
       <select id="getOneToMore" resultMap="oneToMore">
           select customer.id as cid,name,age,orders.id as oid,orderNumber,orderPrice,customer_id
           from customer left join orders on customer.id = orders.customer_id
           where customer.id=#{id};
       select>
   
       <resultMap id="oneToMore" type="customer">
   
           <id property="id" column="cid">id>
   
           <result property="name" column="name">result>
           <result property="age" column="age">result>
   
           <collection property="ordersList" ofType="orders">
               
               <id property="id" column="oid">id>
               
               <result property="orderNumber" column="orderNumber">result>
               <result property="orderPrice" column="orderPrice">result>
           collection>
       resultMap>
   

   输出：

   Customer{id=1, name='张三', age=22, ordersList=[Orders{id=11, orderNumber='20', orderPrice=22.22, customer=null}, Orders{id=12, orderNumber='60', orderPrice=16.66, customer=null}]}
   

   4.4 多对一关联查询

   1. 与一对多最大的区别是关系映射使用的标签，引用类型为实体类使用的标签 与 引用类型为实体类的list集合所使用的标签不同，标签内的属性也不同。
      2.在select语句中，多对一的联表使用inner join ，每个订单肯定对应一个客户，不可能出现客户为null的情况。
   2. 其他需要注意的地方与一对多联表查询一样

   
       <select id="getMoreToOne" resultMap="moreToOne">
           select orders.id oid,orderNumber,orderPrice,customer.id cid,name,age
           from orders inner join customer on customer_id=customer.id
           where orders.id=#{id}
       select>
   
       <resultMap id="moreToOne" type="orders">
           <id property="id" column="oid">id>
           <result property="orderNumber" column="orderNumber">result>
           <result property="orderPrice" column="orderPrice">result>
       
           <association property="cus" javaType="customer">
               <id property="id" column="cid">id>
               <result property="name" column="name">result>
               <result property="age" column="age">result>
           association>
       resultMap>
   

   输出：

   moreToOne = Orders{id=11, orderNumber='20', orderPrice=22.22, customer=Customer{id=1, name='张三', age=22, ordersList=null}}
   

   4.5 一对一

   1. 实体类中关联另一个表的成员变量为另一个实体类
   2. xml文件中映射使用：

   4.6 多对多

   1. 数据库中的表：三张表，两个数据表，一个对应关系表
   2. 实体类中关联另一个表的成员变量为实体类的list集合
   3. xml文件中映射使用：

   5. 事务管理，手动、自动提交

   • 在全局配置文件中可设定事务的管理者，本示例中设置的值为JDBC，由程序员来设置提交、回滚、关闭等事务。

   
               <transactionManager type="JDBC">transactionManager>
   

   1. 在工厂中获取sqlsession时，可设置参数：
      参数为boolean类型，默认为false

   //   3. 取出sqlsession对象
           sqlSession = factory.openSession(参数);//参数默认为`false`
   

   2. 当参数为true时，执行插入、删除、更新等操作时会自动提交事务无需使用：sqlSession.commit();来提交事务。
   3. 当参数为false时，执行插入、删除、更新等操作时会需使用：sqlSession.commit();来提交事务。

   6. 缓存

   • 缓存的作用：缓存是在内存中，数据库是在硬盘中，内存的读写速度远远大于硬盘，查询时会加快查询速度。
   • 缓存的使用：查询时会先到缓存中查询该数据，如果没有则到数据库中查询，查询到的同时会将数据放入缓存，同时从缓存中读取发送给请求者。
   • 数据在缓存中的生命周期：只要有commit()方法执行，就会清空所有缓存。重点：所有
   1. Mybatis默认开启一级缓存。
   2. 默认开启的缓存不需要人为管理。
   3. 如何证明缓存的存在：
      3.1 当执行下面代码时，第一次查询的结果会存入缓存中，第二次查询时直接从缓存中读取

       //    获取id的数据
       @Test
       public void testGetUser(){
           Users user= mapper.getUser(3);
           System.out.println("第一次查询 = " + user);
           Users user1= mapper.getUser(3);
           System.out.println("第二次查询 = " + user1);
       }
   

   查询结果：

   ==>  Preparing: select id ,name,email,age from users where id=?
   ==> Parameters: 3(Integer)
   <==    Columns: id, name, email, age
   <==        Row: 3, 王五, wangwu@163.com, 22
   <==      Total: 1
   第一次查询 = Users{id=3, name='王五', email='wangwu@163.com', age=22}
   第二次查询 = Users{id=3, name='王五', email='wangwu@163.com', age=22}
   

   从查询结果中可以看到，Preparing语句只被执行了一次。

   3. 2 在两次查询中增加事务的提交
      虽然没有任何需要提交的事务，但是只要有commit()方法执行，就会清空所有缓存的数据

       //    获取id的数据
       @Test
       public void testGetUser(){
           Users user= mapper.getUser(3);
           System.out.println("第一次查询 = " + user);
           sqlSession.commit();
           Users user1= mapper.getUser(3);
           System.out.println("第二次查询 = " + user1);
       }
   

   查询的结果：

   ==>  Preparing: select id ,name,email,age from users where id=?
   ==> Parameters: 3(Integer)
   <==    Columns: id, name, email, age
   <==        Row: 3, 王五, wangwu@163.com, 22
   <==      Total: 1
   第一次查询 = Users{id=3, name='王五', email='wangwu@163.com', age=22}
   ==>  Preparing: select id ,name,email,age from users where id=?
   ==> Parameters: 3(Integer)
   <==    Columns: id, name, email, age
   <==        Row: 3, 王五, wangwu@163.com, 22
   <==      Total: 1
   第二次查询 = Users{id=3, name='王五', email='wangwu@163.com', age=22}
   

   可以看到提交了两次select语句Preparing: select id ,name,email,age from users where id=?

   面向接口编程的四条要点

   1. 类中的成员变量为接口
   2. 方法的参数设计为接口
   3. 返回值设计为接口
   4. 接口指向实现类。new一个对象，类型为接口

   动态代理

   目标对象必须实现接口，代理对象只能增强目标对象实现的接口的方法。
   动态代理的实现是固定的：

   • 定义两个接口：

   public interface TargetInterface1 {
       void tI1fun1();
       String  tI1fun2(int arg);
   }
   

   public interface TargetInterface2 {
       void tI2Fun1();
       String tI2Fun2(int num);
   }
   

   • 定义目标对象，实现这两个接口：

   public class TargetClassOne implements TargetInterface1, TargetInterface2 {
   
       @Override
       public void tI1fun1() {System.out.println("实现接口1的方法1");}
   
       @Override
       public String tI1fun2(int num) {System.out.println("实现接口1的方法2，接收参数"+num);
           return "接口1方法2返回的内容";}
   
       @Override
       public void tI2Fun1() {System.out.println("实现接口2的方法1"); }
   
       @Override
       public String tI2Fun2(int num) {System.out.println("实现接口2的方法2，接收参数"+num);
           return "接口2方法2返回的内容"; }
   }
   

   • 定义动态代理工厂类（固定的格式，只需要修改增强功能就可以）：
     通过反射机制，自己弄个了类出来

   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;
   
   public class ProxyFactroy<T> {
       public T targetObject;
   
       public ProxyFactroy(T targetObject) {
           this.targetObject = targetObject;
       }
       public Object getProxy(){
           return Proxy.newProxyInstance(
                   // ClassLoader loader, 类加载器，完成目标对象的加载
                   targetObject.getClass().getClassLoader(),
                   // Class[] interfaces, 目标对象实现的所有接口
                   targetObject.getClass().getInterfaces(),
                   // InvocationHandler h 实现代理功能的接口，使用匿名内部类实现
                   new InvocationHandler() {
                       @Override
                       public Object invoke(
                               Object proxy, // 创建的代理对象，动态代理的目的就是要它
                               Method method, // 目标对象实现的接口中的方法
                               Object[] args // 目标方法的参数
                       ) throws Throwable {
                           System.out.println("创建的代理对象中增强的功能1");
                           Object invoke = method.invoke(targetObject, args);
                           System.out.println("创建的代理对象中增强的功能2");
                           return invoke;
                       }
                   }
           );
       }
   }
   
   

   • 调用

       public void testjdk(){
           // 将目标类出入代理对象工厂
           ProxyFactroy proxy = new ProxyFactroy(new TargetClassOne());
           // 获得动态代理对象（强转为接口1）
           TargetInterface1 proxyObj = (TargetInterface1)proxy.getProxy();
           // 可以执行目标类实现接口的方法
           proxyObj.tI1fun1();
           String s = proxyObj.tI1fun2(20);
           System.out.println(s);
           System.out.println("====================上面是接口1的方法，下面是接口2的方法===========================");
           // 获得动态代理对象（强转为接口2）
           TargetInterface2 proxyObj1 = (TargetInterface2)proxyObj;
           // 可以执行目标类实现接口的方法
           proxyObj1.tI2Fun1();
           String s1 = proxyObj1.tI2Fun2(50);
           System.out.println(s1);
       }
   

   • 输出

   创建的代理对象中增强的功能1
   实现接口1的方法1
   创建的代理对象中增强的功能2
   创建的代理对象中增强的功能1
   实现接口1的方法2，接收参数20
   创建的代理对象中增强的功能2
   接口1方法2返回的内容
   ====================上面是接口1的方法，下面是接口2的方法===========================
   创建的代理对象中增强的功能1
   实现接口2的方法1
   创建的代理对象中增强的功能2
   创建的代理对象中增强的功能1
   实现接口2的方法2，接收参数50
   创建的代理对象中增强的功能2
   接口2方法2返回的内容
   

   你可能感兴趣的:(Java,java,spring,maven)

   • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++） 华为OD题库 华为od链表java
     须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
   • 学习JavaEE的日子 Day32 线程池 A 北枝 学习JavaEE学习java-eejava线程池
     Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
   • SpringMVC设置全局异常处理器 水岸齐天 javaspring
     文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
   • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】 还算善良_ 私有代码库工具类javalist数据结构
     packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
   • springboot集成logback-spring.xml文件 RT_0114 SpringBootspringbootspringlogback
     彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
   • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shirojavajava安全开发语言
     请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
   • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？ 大龄下岗程序员 mysqljavamysqlspring
     Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
   • 3、JavaWeb-Ajax/Axios-前端工程化-Element 所谓远行Misnearch #JavaWeb前端ajaxelementuijava前端框架
     P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
   • 第一次用eclipse,导入项目错误Plug-in “org.eclipse.m2e.editor“ was unable to instantiate MavenPomEditor zhangfeng1133 eclipsejavaide
     第一次用eclipse,导入项目错误Plug-in"org.eclipse.m2e.editor"wasunabletoinstantiateMavenPomEditor。各种项目包，都不存在，maven应该能自动载入类包，比Php的composer方便太多Thecontainer'MavenDependencies'referencesnonexistinglibrary'C:\Users\Ad
   • eclipse导入项目 warning报错 org.springframework.ide.eclipse.core.springnature zhangfeng1133 ideeclipsejava
     报错org.springframework.ide.eclipse.core.springnature报错信息"org.springframework.ide.eclipse.core.springnature"通常表示EclipseIDE中与Spring框架集成的插件出现了问题。这个错误可能是因为SpringIDE插件没有正确安装或配置，或者Eclipse的更新过程中出现了问题。解决方法：确认S
   • 枚举使用笔记 万变不离其宗_8 项目笔记笔记
     1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
   • linux安装docker及docker-compose 部署spring boot项目 时而有事儿 dockerlinuxdockerlinuxspringboot
     linux系统环境：centos5.14本篇描述的是在centos系统版本下安装docker，如果是ubuntu版本，请看这篇文章：linuxubuntu20安装docker和docker-compose-CSDN博客正文：安装docker和docker-compose安装docker---------运行命名等待安装完成遇到选择直接输入yyuminstall-yyum-utilsdevice-m
   • Python dict字符串转json对象，小数精度丢失问题 朝如青丝 暮成雪 jsonpython
     一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
   • java实体中返回前端的double类型四舍五入（格式化） 婲落ヽ紅顏誶 java
     根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
   • Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java数据结构开发语言
     在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
   • Java学习笔记01 .wsy. 日常java学习笔记
     1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
   • Java回溯知识点（含面试大厂题和源码） 一成码农 java面试开发语言
     回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
   • Azkaban各种类型的Job编写 __元昊__
     一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
   • java基础相关面试题详细总结 。。。。。96 java开发语言
     1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
   • javascript 日期转换为时间戳，时间戳转换为日期的函数 cdcdhj javascript学习日记javascript开发语言ecmascript
     日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
   • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
     Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
   • COMP315 JavaScript Cloud Computing for E Commerce zhuyu0206girl javascript开发语言ecmascript
     Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
   • JSON与AJAX：网页交互的利器 入冉心 jsonajax前端
     在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
   • 程序员开发技术整理 laizhixue 学习前端框架
     前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
   • javascript的数据类型及转换 田小田txt
     一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
   • java线程之Lock的使用 dimdark
     目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
   • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解 爱跑步的程序员~ 刷题蓝桥杯省赛
     文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
   • Java学习笔记04：Java_数组 JasonYangQ Javajava
     文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
   • 【设计模式】Java 设计模式之桥接模式（Bridge） 新手村长 Java设计模式设计模式java桥接模式
     桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
   • Websocket服务监听收发消息 beiback Java服务器问题websocket网络协议网络
     目录1.pom依赖坐标2.项目配置端口和项目包名2.创建处理器3.注册处理器4.前端页面1.pom依赖坐标org.springframework.bootspring-boot-starter-websocket2.项目配置端口和项目包名application.propertiesserver.port=8088//路径规范：为应用的所有servlet提供一个统一的前缀，使URL结构更加清晰和一致
   • ASM系列四 利用Method 组件动态注入方法逻辑 lijingyao8206 字节码技术jvmAOP动态代理ASM
             这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
   • java编程思想 --内部类 百合不是茶 java内部类匿名内部类
     内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅   1,内部类的创建  内部类是创建在类中的 package com.wj.InsideClass; /* * 内部类的创建 */ public class CreateInsideClass { public CreateInsideClass(
   • web.xml报错 crabdave web.xml
     web.xml报错   The content of element type "web-app" must match "(icon?,display-  name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
   • 泛型类的自定义 麦田的设计者 javaandroid泛型
        为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 采用泛型类，完成扩展。   例如有一个学生类     Student{ Student(){ System.out.println("I'm a student....."); } }  有一个老师类  
   • CSS清除浮动的4中方法 IT独行者 JavaScriptUIcss
     清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 1、结尾处加空div标签 clear:both 1 2 3 4 .div 1 { background : #000080 ; border : 1px   s
   • Cygwin使用windows的jdk 配置方法 _wy_ jdkwindowscygwin
     1.[vim /etc/profile]    JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43)    PATH="$JAVA_HOME/bin:${PATH}"    CLAS
   • linux下安装maven 无量 mavenlinux安装
     Linux下安装maven(转) 1.首先到Maven官网 下载安装文件，目前最新版本为3.0.3，下载文件为 apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 2.进入下载文件夹，找到下载的文件，运行如下命令解压 tar -xvf  apache-maven-2.2.1-bin.tar.gz 解压后的文件夹
   • tomcat的https 配置,syslog-ng配置 aichenglong tomcathttp跳转到httpssyslong-ng配置syslog配置
     1) tomcat配置https,以及http自动跳转到https的配置     1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令)      keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
   • 关于领号活动总结 alafqq 活动
     关于某彩票活动的总结 具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 活动要求 1，随机性，一定要有随机性； 2，最少中奖概率，如果注数为3200注，则最多中4注 3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 解决方案 1，事先产生随机数1000个，并打
   • java数据结构 冒泡排序的遍历与排序 百合不是茶 java
     java的冒泡排序是一种简单的排序规则   冒泡排序的原理：           比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样；         针对所有的元素重复以上的步骤，除了最后一个     例题；将int array[]
   • JS检查输入框输入的是否是数字的一种校验方法 bijian1013 js
     如下是JS检查输入框输入的是否是数字的一种校验方法： <form method=post target="_blank"> 数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br> </form>
   • Test注解的两个属性：expected和timeout bijian1013 javaJUnitexpectedtimeout
     JUnit4：Test文档中的解释： 　　The Test annotation supports two optional parameters. 　　The first, expected, declares that a test method should throw an exception. 　　If it doesn't throw an exception or if it
   • [Gson二]继承关系的POJO的反序列化 bit1129 POJO
     父类     package inheritance.test2; import java.util.Map; public class Model { private String field1; private String field2; private Map<String, String> infoMap
   • 【Spark八十四】Spark零碎知识点记录 bit1129 spark
     1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中  
   • WAS各种脚本作用大全 ronin47 WAS 脚本
     　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 　　　 获取下载 这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
   • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句 bylijinnan switch
     借鉴网上的思路，用java实现： public class NoIfWhile { /** * @param args * * find x=1+2+3+....n */ public static void main(String[] args) { int n=10; int re=find(n); System.o
   • Netty源码学习-ObjectEncoder和ObjectDecoder bylijinnan javanetty
     Netty中传递对象的思路很直观： Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 那把对象序列化为字节流，就可以在Netty中传递对象了 相应的从ChannelBuffer恢复对象，就是反序列化的过程 Netty已经封装好ObjectEncoder和ObjectDecoder 先看ObjectEncoder ObjectEncoder是往外发送
   • spring 定时任务中cronExpression表达式含义 chicony cronExpression
     一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 代表含义            是否必须 允许的取值范围         &nb
   • Nutz配置Jndi ctrain JNDI
     1、使用JNDI获取指定资源： var ioc = { dao : { type :"org.nutz.dao.impl.NutDao", args : [ {jndi :"jdbc/dataSource"} ] } } 以上方法,仅需要在容器中配置好数据源,注入到NutDao即可.
   • 解决 /bin/sh^M: bad interpreter: No such file or directory daizj shell
     在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。   分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 解决： 1）在windows下转换： 利用一些编辑器如UltraEdit或EditPlus等工具
   • [转]for 循环为何可恨？ dcj3sjt126com 程序员读书
       Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
   • Android实用小技巧 dcj3sjt126com android
     1、去掉所有Activity界面的标题栏 　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar"   2、去掉所有Activity界面的TitleBar 和StatusBar  　　修改AndroidManifes
   • Oracle 复习笔记之序列 eksliang Oracle 序列sequenceOracle sequence
     转载请出自出处：http://eksliang.iteye.com/blog/2098859 1.序列的作用 序列是用于生成唯一、连续序号的对象 一般用序列来充当数据库表的主键值 2.创建序列语法如下：   create sequence s_emp start with 1 --开始值 increment by 1 --増长值 maxval
   • 有“品”的程序员 gongmeitao 工作
     完美程序员的10种品质　　   完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的   完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强   （范围：用简单方式解决复杂问题）　　
   • 使用KeleyiSQLHelper类进行分页查询 hvt sql.netC#asp.nethovertree
     本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
   • SVG 教程 （三）圆形，椭圆，直线 天梯梦 svg
     SVG <circle> SVG 圆形 - <circle> <circle> 标签可用来创建一个圆： 下面是SVG代码： <svg xmlns="http://www.w3.org/2000/svg" version="1.1"> <circle cx="100" c
   • 链表栈 luyulong java数据结构
     public class Node { private Object object; private Node next; public Node() { this.next = null; this.object = null; } public Object getObject() { return object; } public
   • 基础数据结构和算法十：2-3 search tree sunwinner Algorithm2-3 search tree
       Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
   • spring配置定时任务 stunizhengjia springtimer
     最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到：     //------------------------定时任务调用的方法------------------------------ /** * 存储过程定时器 */ publi
   • ITeye 8月技术图书有奖试读获奖名单公布 ITeye管理员 活动
     ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 8月试读活动回顾： http://webmaster.iteye.com/blog/2102830 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《跨终端Web》 gleams：http
   按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
   首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

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