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)

   • 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
   • 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，支持多线程、分布式抓取，以及丰富的
   • 博客网站制作教程 2401_85194651 javamaven
     首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
   • 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.