Junit测试打印日志

最新推荐文章于 2023-05-18 20:10:28 发布
最新推荐文章于 2023-05-18 20:10:28 发布
阅读量2.5k 收藏 3
点赞数
分类专栏： java 文章标签： junit
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TuRanHaoAnJing/article/details/84071441
版权

Junit测试打印日志

maven项目构建

pom文件

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

    <groupId>com.zmq</groupId>
    <artifactId>database-test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.build.timestamp.format>yyMMdd</maven.build.timestamp.format>
        <runtime.version>1.8</runtime.version>
        <autoconfig-plugin-version>1.2</autoconfig-plugin-version>
        <spring-version>4.2.1.RELEASE</spring-version>
        <spring-amqp-version>1.5.1.RELEASE</spring-amqp-version>
    </properties>
    <dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring-version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring-version}</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!--oracle-->
        <dependency>
            <groupId>ojdbc</groupId>
            <artifactId>ojdbc</artifactId>
            <version>6</version>
        </dependency>
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.1.0</version>
        </dependency>

        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.11</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.6</version>
            <scope>provided</scope>
        </dependency>

        <!--日志-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.13</version>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

</project>

log4j.properties

### 设置Logger输出级别和输出目的地 ### debug更详细,如果设为info那么打印出的表数据遇到字符串就不显示，此外还有logfile
log4j.rootLogger=debug,stdout  

### 把日志信息输出到控制台 ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender   
#log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout   

### 把日志信息输出到文件：jbit.log ###
log4j.appender.logfile=org.apache.log4j.FileAppender   
log4j.appender.logfile.File=jbit.log   
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout   
log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %F %p %m%n   
log4j.logger.mapperNS =TRACE
###显示SQL语句部分
log4j.logger.com.mybatis=DEBUG  
log4j.logger.com.mybatis.common.jdbc.SimpleDataSource=DEBUG   
log4j.logger.com.mybatis.common.jdbc.ScriptRunner=DEBUG   
log4j.logger.com.mybatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG   
log4j.logger.java.sql.Connection=DEBUG  
log4j.logger.java.sql.Statement=DEBUG  
log4j.logger.java.sql.PreparedStatement=DEBUG  
log4j.logger.java.sql.ResultSet=DEBUG  
# 设置不打印springframework.apache等多余信息
log4j.logger.org.springframework=error 
log4j.logger.org.apache=ERROR  
log4j.logger.org.mybatis=ERROR

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<settings>
		<setting name="cacheEnabled" value="true" />
		<setting name="lazyLoadingEnabled" value="false" />
		<setting name="multipleResultSetsEnabled" value="true" />
		<setting name="useColumnLabel" value="true" />
		<setting name="useGeneratedKeys" value="true" />
		<setting name="defaultExecutorType" value="SIMPLE" />
		<setting name="defaultStatementTimeout" value="25" />
	</settings>

	<typeAliases>
		<package name="mapper" />
	</typeAliases>
</configuration>

dao-test.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<import resource="datasource-test.xml" />

	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="configLocation" value="classpath:/mybatis-config.xml" />
		<property name="mapperLocations">
			<list>
				<value>
					classpath:/OrderMapper.xml
				</value>
			</list>
		</property>
	</bean>

	<bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="mapper" />
		<property name="sqlSessionFactory" ref="sqlSessionFactory" />
	</bean>

</beans>

datasource-test.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
		<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
		<!-- 数据库 url -->
		<property name="url" value="jdbc:oracle:thin:@local:test" />
		<!-- 配置密码加密和统计相关参数，统计慢sql的单位为毫秒，超过1秒钟的sql为慢sql -->
		<property name="username" value="null" />
		<property name="password" value="null" />
		<property name="filters" value="config,stat" />
		<property name="connectionProperties"
			value="druid.stat.slowSqlMillis=1000;druid.stat.logSlowSql=true;druid.stat.mergeSql=true" />
		<!-- 配置初始化大小、最小、最大 -->
		<property name="initialSize" value="5" />
		<property name="minIdle" value="5" />
		<property name="maxActive" value="100" />
		<property name="maxWait" value="1000" />
		<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，相当于C3P0的idleConnectionTestPeriod 参数，单位是毫秒 -->
		<property name="timeBetweenEvictionRunsMillis" value="140000" />
		<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
		<property name="minEvictableIdleTimeMillis" value="300000" />
		<property name="numTestsPerEvictionRun" value="3" />
		<!-- 测试连接，单位为毫秒 -->
		<property name="validationQueryTimeout" value="1000" />
		<property name="validationQuery" value="SELECT 1 from dual" />
		<property name="testWhileIdle" value="true" />
		<property name="testOnBorrow" value="false" />
		<property name="testOnReturn" value="false" />
		<!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
		<!-- 如果用Oracle，则把poolPreparedStatements配置为true，mysql可以配置为false。 -->
		<property name="poolPreparedStatements" value="true" />
		<property name="maxPoolPreparedStatementPerConnectionSize" value="50" />
	</bean>
</beans>

OrderMapper.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="mapper.OrderMapper">
  <resultMap id="BaseResultMap" type="mapper.Order">
    <id column="ID" jdbcType="BIGINT" property="id" />
    <result column="ORDER_NO" jdbcType="VARCHAR" property="orderNo" />
  
    <result column="CREATED_TIME" jdbcType="TIMESTAMP" property="createdTime" />
    <result column="CREATED_PERSON" jdbcType="VARCHAR" property="createdPerson" />
    <result column="UPDATED_TIME" jdbcType="TIMESTAMP" property="updatedTime" />
    <result column="UPDATED_PERSON" jdbcType="VARCHAR" property="updatedPerson" />
    
  </resultMap>
  <sql id="Example_Where_Clause">
    <where>
    <if test="rownum" >
      (
    </if>
      <foreach collection="oredCriteria" item="criteria" separator="or">
        <if test="criteria.valid">
          <trim prefix="(" prefixOverrides="and" suffix=")">
            <foreach collection="criteria.criteria" item="criterion">
              <choose>
                <when test="criterion.noValue">
                  and ${criterion.condition}
                </when>
                <when test="criterion.singleValue">
                  and ${criterion.condition} #{criterion.value}
                </when>
                <when test="criterion.betweenValue">
                  and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
                </when>
                <when test="criterion.listValue">
                  and ${criterion.condition}
                  <foreach close=")" collection="criterion.value" item="listItem" open="(" separator=",">
                    #{listItem}
                  </foreach>
                </when>
              </choose>
            </foreach>
          </trim>
        </if>
      </foreach>
      <if test="rownum">
        )
      </if>
    </where>

  </sql>

  <sql id="Base_Column_List">
    ID, ORDER_NO, 
    CREATED_PERSON, UPDATED_TIME, UPDATED_PERSON, 
  </sql>
  <select id="selectByExample" parameterType="mapper.OrderExample" resultMap="BaseResultMap">
    select
    <if test="distinct">
      distinct
    </if>
    <include refid="Base_Column_List" />
    from T_THIRD_TAXI_ORDER
    <if test="_parameter != null">
      <include refid="Example_Where_Clause" />
    </if>
    <if test="orderByClause != null">
      order by ${orderByClause}
    </if>

    <if test="rownum">
      and ROWNUM <![CDATA[ < ]]> 1000
    </if>
  </select>
  <select id="selectByPrimaryKey" parameterType="long" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    from T_THIRD_TAXI_ORDER
    where ID = #{id,jdbcType=BIGINT}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="long">
    delete from T_THIRD_TAXI_ORDER
    where ID = #{id,jdbcType=BIGINT}
  </delete>

  <insert id="insert" parameterType="mapper.Order">
    <selectKey keyProperty="id" order="BEFORE" resultType="long">
      SELECT SEQ_THIRD_TAXI_ORDER.NEXTVAL FROM DUAL
    </selectKey>
    insert into T_THIRD_TAXI_ORDER (ID, ORDER_NO,CREATED_TIME,
      CREATED_PERSON, UPDATED_TIME, UPDATED_PERSON,
   )
    values (#{id,jdbcType=BIGINT}, #{orderNo,jdbcType=VARCHAR}, #{createdTime,jdbcType=TIMESTAMP},
      #{createdPerson,jdbcType=VARCHAR}, #{updatedTime,jdbcType=TIMESTAMP}, #{updatedPerson,jdbcType=VARCHAR})
  </insert>

  <select id="countByExample" parameterType="mapper.OrderExample" resultType="java.lang.Long">
    select count(*) from T_THIRD_TAXI_ORDER
    <if test="_parameter != null">
      <include refid="Example_Where_Clause" />
    </if>
  </select>

  <update id="updateByPrimaryKeySelective" parameterType="mapper.Order">
    update T_THIRD_TAXI_ORDER
    <set>
      <if test="orderNo != null">
        ORDER_NO = #{orderNo,jdbcType=VARCHAR},
      </if>
      <if test="createdTime != null">
        CREATED_TIME = #{createdTime,jdbcType=TIMESTAMP},
      </if>
      <if test="createdPerson != null">
        CREATED_PERSON = #{createdPerson,jdbcType=VARCHAR},
      </if>
      <if test="updatedTime != null">
        UPDATED_TIME = #{updatedTime,jdbcType=TIMESTAMP},
      </if>
      <if test="updatedPerson != null">
        UPDATED_PERSON = #{updatedPerson,jdbcType=VARCHAR},
      </if>
     
    </set>
    where ID = #{id,jdbcType=BIGINT}
  </update>


  <select id="selectByPager" parameterType="java.util.Map" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    <![CDATA[
		FROM (
		  SELECT A.*, ROWNUM RN FROM(
		    SELECT * FROM T_THIRD_TAXI_ORDER T WHERE
		  	  T.ORDER_STATE = #{orderState,jdbcType=CHAR} AND
		  	  T.CREATED_TIME > #{startTime,jdbcType=TIMESTAMP} AND
		      T.CREATED_TIME <= #{endTime,jdbcType=TIMESTAMP}
		      ORDER BY T.CREATED_TIME) A
		) WHERE RN <= #{end,jdbcType=VARCHAR} AND RN >  #{begin,jdbcType=VARCHAR}
	]]>
  </select>
</mapper>

OrderMapper

package mapper;


import java.util.List;
import java.util.Map;

public interface OrderMapper {
    long countByExample(OrderExample example);

    int deleteByPrimaryKey(long id);

    int insert(Order record);

    List<ThirdTaxiOrder> selectByExample(OrderExample example);

    ThirdTaxiOrder selectByPrimaryKey(long id);

    int updateByPrimaryKeySelective(Order record);

    List<ThirdTaxiOrder> selectByPager(Map<String, Object> map);
}

Order

package mapper;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.io.Serializable;
import java.util.Date;

@Setter
@Getter
@ToString
public class Order implements Serializable {
	private static final long serialVersionUID = 1L;

	private long id;

    private String orderNo;

    private Date createdTime;

    private String createdPerson;

    private Date updatedTime;

    private String updatedPerson;

}

OrderExample

package mapper;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class OrderExample {
    protected String orderByClause;

    protected boolean distinct;

    protected boolean rownum;

    protected List<Criteria> oredCriteria;

    public OrderExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }
    public void setRownum(boolean rownum) {
        this.rownum = rownum;
    }
    public boolean isRownum() {
        return rownum;
    }
    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andIdIsNull() {
            addCriterion("ID is null");
            return (Criteria) this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion("ID is not null");
            return (Criteria) this;
        }

        public Criteria andIdEqualTo(long value) {
            addCriterion("ID =", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotEqualTo(long value) {
            addCriterion("ID <>", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThan(long value) {
            addCriterion("ID >", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThanOrEqualTo(long value) {
            addCriterion("ID >=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThan(long value) {
            addCriterion("ID <", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThanOrEqualTo(long value) {
            addCriterion("ID <=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdIn(List<Long> values) {
            addCriterion("ID in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotIn(List<Long> values) {
            addCriterion("ID not in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdBetween(long value1, long value2) {
            addCriterion("ID between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotBetween(long value1, long value2) {
            addCriterion("ID not between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andOrderNoIsNull() {
            addCriterion("ORDER_NO is null");
            return (Criteria) this;
        }

        public Criteria andOrderNoIsNotNull() {
            addCriterion("ORDER_NO is not null");
            return (Criteria) this;
        }

        public Criteria andOrderNoEqualTo(String value) {
            addCriterion("ORDER_NO =", value, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoNotEqualTo(String value) {
            addCriterion("ORDER_NO <>", value, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoGreaterThan(String value) {
            addCriterion("ORDER_NO >", value, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoGreaterThanOrEqualTo(String value) {
            addCriterion("ORDER_NO >=", value, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoLessThan(String value) {
            addCriterion("ORDER_NO <", value, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoLessThanOrEqualTo(String value) {
            addCriterion("ORDER_NO <=", value, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoLike(String value) {
            addCriterion("ORDER_NO like", value, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoNotLike(String value) {
            addCriterion("ORDER_NO not like", value, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoIn(List<String> values) {
            addCriterion("ORDER_NO in", values, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoNotIn(List<String> values) {
            addCriterion("ORDER_NO not in", values, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoBetween(String value1, String value2) {
            addCriterion("ORDER_NO between", value1, value2, "orderNo");
            return (Criteria) this;
        }

        public Criteria andOrderNoNotBetween(String value1, String value2) {
            addCriterion("ORDER_NO not between", value1, value2, "orderNo");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeIsNull() {
            addCriterion("CREATED_TIME is null");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeIsNotNull() {
            addCriterion("CREATED_TIME is not null");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeEqualTo(Date value) {
            addCriterion("CREATED_TIME =", value, "createdTime");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeNotEqualTo(Date value) {
            addCriterion("CREATED_TIME <>", value, "createdTime");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeGreaterThan(Date value) {
            addCriterion("CREATED_TIME >", value, "createdTime");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("CREATED_TIME >=", value, "createdTime");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeLessThan(Date value) {
            addCriterion("CREATED_TIME <", value, "createdTime");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeLessThanOrEqualTo(Date value) {
            addCriterion("CREATED_TIME <=", value, "createdTime");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeIn(List<Date> values) {
            addCriterion("CREATED_TIME in", values, "createdTime");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeNotIn(List<Date> values) {
            addCriterion("CREATED_TIME not in", values, "createdTime");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeBetween(Date value1, Date value2) {
            addCriterion("CREATED_TIME between", value1, value2, "createdTime");
            return (Criteria) this;
        }

        public Criteria andCreatedTimeNotBetween(Date value1, Date value2) {
            addCriterion("CREATED_TIME not between", value1, value2, "createdTime");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonIsNull() {
            addCriterion("CREATED_PERSON is null");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonIsNotNull() {
            addCriterion("CREATED_PERSON is not null");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonEqualTo(String value) {
            addCriterion("CREATED_PERSON =", value, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonNotEqualTo(String value) {
            addCriterion("CREATED_PERSON <>", value, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonGreaterThan(String value) {
            addCriterion("CREATED_PERSON >", value, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonGreaterThanOrEqualTo(String value) {
            addCriterion("CREATED_PERSON >=", value, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonLessThan(String value) {
            addCriterion("CREATED_PERSON <", value, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonLessThanOrEqualTo(String value) {
            addCriterion("CREATED_PERSON <=", value, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonLike(String value) {
            addCriterion("CREATED_PERSON like", value, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonNotLike(String value) {
            addCriterion("CREATED_PERSON not like", value, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonIn(List<String> values) {
            addCriterion("CREATED_PERSON in", values, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonNotIn(List<String> values) {
            addCriterion("CREATED_PERSON not in", values, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonBetween(String value1, String value2) {
            addCriterion("CREATED_PERSON between", value1, value2, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andCreatedPersonNotBetween(String value1, String value2) {
            addCriterion("CREATED_PERSON not between", value1, value2, "createdPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeIsNull() {
            addCriterion("UPDATED_TIME is null");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeIsNotNull() {
            addCriterion("UPDATED_TIME is not null");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeEqualTo(Date value) {
            addCriterion("UPDATED_TIME =", value, "updatedTime");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeNotEqualTo(Date value) {
            addCriterion("UPDATED_TIME <>", value, "updatedTime");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeGreaterThan(Date value) {
            addCriterion("UPDATED_TIME >", value, "updatedTime");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("UPDATED_TIME >=", value, "updatedTime");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeLessThan(Date value) {
            addCriterion("UPDATED_TIME <", value, "updatedTime");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeLessThanOrEqualTo(Date value) {
            addCriterion("UPDATED_TIME <=", value, "updatedTime");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeIn(List<Date> values) {
            addCriterion("UPDATED_TIME in", values, "updatedTime");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeNotIn(List<Date> values) {
            addCriterion("UPDATED_TIME not in", values, "updatedTime");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeBetween(Date value1, Date value2) {
            addCriterion("UPDATED_TIME between", value1, value2, "updatedTime");
            return (Criteria) this;
        }

        public Criteria andUpdatedTimeNotBetween(Date value1, Date value2) {
            addCriterion("UPDATED_TIME not between", value1, value2, "updatedTime");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonIsNull() {
            addCriterion("UPDATED_PERSON is null");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonIsNotNull() {
            addCriterion("UPDATED_PERSON is not null");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonEqualTo(String value) {
            addCriterion("UPDATED_PERSON =", value, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonNotEqualTo(String value) {
            addCriterion("UPDATED_PERSON <>", value, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonGreaterThan(String value) {
            addCriterion("UPDATED_PERSON >", value, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonGreaterThanOrEqualTo(String value) {
            addCriterion("UPDATED_PERSON >=", value, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonLessThan(String value) {
            addCriterion("UPDATED_PERSON <", value, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonLessThanOrEqualTo(String value) {
            addCriterion("UPDATED_PERSON <=", value, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonLike(String value) {
            addCriterion("UPDATED_PERSON like", value, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonNotLike(String value) {
            addCriterion("UPDATED_PERSON not like", value, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonIn(List<String> values) {
            addCriterion("UPDATED_PERSON in", values, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonNotIn(List<String> values) {
            addCriterion("UPDATED_PERSON not in", values, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonBetween(String value1, String value2) {
            addCriterion("UPDATED_PERSON between", value1, value2, "updatedPerson");
            return (Criteria) this;
        }

        public Criteria andUpdatedPersonNotBetween(String value1, String value2) {
            addCriterion("UPDATED_PERSON not between", value1, value2, "updatedPerson");
            return (Criteria) this;
        }  
   
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}

测试基类

import mapper.ThirdTaxiOrderMapper;
import org.apache.ibatis.io.ResolverUtil;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.PropertyConfigurator;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public abstract class Test {
    protected ThirdTaxiOrderMapper thirdTaxiOrderMapper;
    private ApplicationContext ctx = null;
    
    @Before
    public void init() {
        /*PropertyConfigurator.configure(ResolverUtil.Test.class.getClassLoader().getResource("log4j.properties"));
        BasicConfigurator.configure();*/
        ctx = new ClassPathXmlApplicationContext("classpath:/dao-test.xml");
        thirdTaxiOrderMapper = (ThirdTaxiOrderMapper) ctx.getBean("thirdTaxiOrderMapper");
    }

    @Test
    public abstract void testMethods();
    
}

测试类



import mapper.Order;
import mapper.OrderExample;
import util.DateTimeUtils;
import util.RandomNumberUtil;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class OrderMapperTest extends Test {
	private void selectInitByPager() {
		OrderExample example = new OrderExample();
		try {
            example.createCriteria().andOrderStateEqualTo("01")
                    .andCreatedTimeGreaterThan(DateTimeUtils.getStringToDateTime("2017-1-30", DateTimeUtils.DATE_FORMAT_YYYY_MM_DD))
                    .andCreatedTimeLessThan(DateTimeUtils.getStringToDateTime("2018-11-15", DateTimeUtils.DATE_FORMAT_YYYY_MM_DD))
                    ;
            example.getOredCriteria().add(example.createCriteria().andOrderStateEqualTo("06")
                    .andUpdatedTimeLessThan(DateTimeUtils.getStringToDateTime("2018-11-1", DateTimeUtils.DATE_FORMAT_YYYY_MM_DD)));
            
		} catch (Exception e) {
			e.printStackTrace();
		}
		List<ThirdTaxiOrder> thirdTaxiOrders = thirdTaxiOrderMapper.selectByExample(example);
		if (thirdTaxiOrders != null) {
			System.out.println(thirdTaxiOrders.size());
			for (ThirdTaxiOrder thirdTaxiOrder : thirdTaxiOrders) {
				System.out.println(thirdTaxiOrder.getOrderNo());
			}
		}
	}

	@Override
	public void testMethods() {

		selectInitByPager();
}

测试结果

com.intellij.rt.execution.junit.JUnitStarter -ideVersion5 -junit4 ThirdTaxiOrderMapperTest
INFO - {dataSource-1} inited
DEBUG - ==>  Preparing: select ID, ORDER_NO,CREATED_TIME, CREATED_PERSON, UPDATED_TIME, UPDATED_PERSON from T_ORDER WHERE ( ORDER_NO = ? and CREATED_TIME > ? and CREATED_TIME < ? ) or( ORDER_NO = ? and UPDATED_TIME < ? ) 
DEBUG - ==> Parameters: 01(String), 2017-01-30 00:00:00.0(Timestamp), 2018-11-15 00:00:00.0(Timestamp), 06(String), 2018-11-01 00:00:00.0(Timestamp)
DEBUG - <==      Total: 3208
DEBUG - {conn-10005, pstmt-20000} enter cache
3208

Process finished with exit code 0
TuRanHaoAnJing
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Junit(单元测试)与Log4j(日志)的搭配
sxl123123123的博客
08-10 1908
junit与Log4j搭配首先在使用junit与Log4j的时候先映入jar包（jar包参照上篇，项目结构图所示.）1.为什么学习junit与Log4j 木有使用Junit的时候,一个类里面只能有一个main方法,而且测试的时候只能运行main方法,如果说只想测试其中的一个方法,注释掉其它的方法.期望: 当前类里面的方法想写几个就写个,想测试其中的一个方法,只需要在指定的方法上面右
Junit springboot打印测试方法信息
08-19
Junit SpringBoot 打印测试...使用 Junit 和 SpringBoot 框架进行单元测试时，我们可以使用 `TestName` 对象来获取当前测试方法的名称，并使用 `@Log4j2` 注解来使用 Log4j2 日志框架，从而打印当前测试方法的信息。
Junit单元测试使用log4j输出日志
热门推荐
z69183787的专栏
06-15 2万+
Junit+spring+log4j整合之所以麻烦，是因为spring与log4j的整合，是放在web.xml里的，随tomcat启动后，spring才会加载log4j，而用junit测试是不需要tomcat启动的，所以Junit与log4j的整合才比较费劲。Junit使用spring时，若spring没加载到log4j就会报以下警告： log4j:WARN No appenders c
android studio junit 打印日志,AndroidStudio 使用Gradle 控制Log 日志输出
weixin_30949673的博客
06-03 721
我们在开发APP的时候，在测试的时候需要打Debug 包，在正式发布的时候打 Release 包；但是在正式发布的时候我们需要把在研发阶段的Log日志打印给取消掉，设置用户不可见，研发可见。过多的打印Log日志也是会影响APP的性能的，所以我们就以此做区分！1、常规的操作我们是创建Log管理类来管理Log日志打印2、通过 配置gradle buildConfigField("boolean", "...
Junit测试，Log4j日志.md
TheKeyFigure的博客
07-15 427
Junit单元测试 Junit单元测试，它可以让方法独立执行。这样我们每写完一个方法，就可以使用Junit运行，检查方法的正确性。 //运行在@Test直接之前 @Before public void before(){ System.out.println("运行在Test之前"); } //加上@Test注解的方法，可以独立执行。 //绿色：表示正常执行 //红色：执行出现问题 @Test public void show(){ int a=10; int b=20;
day27-基础加强03
xunan1998的博客
11-05 133
1.单元测试 1.1概述【理解】 JUnit是一个 Java 编程语言的单元测试工具。JUnit 是一个非常重要的测试工具 1.2特点【理解】 JUnit是一个开放源代码的测试工具。 提供注解来识别测试方法。 JUnit测试可以让你编写代码更快，并能提高质量。 JUnit优雅简洁。没那么复杂，花费时间较少。 JUnit在一个条中显示进度。如果运行良好则是绿色；如果运行失败，则变成红色。 1.3使用步骤【应用】 使用步骤 将junit的jar包导入到工程中 junit-4.9.jar 编写测试方法该
使用JUnit进行单元测试、JUL日志系统配置、Mybatis日志系统配置、Lombok开启日志
m0_73976305的博客
05-18 791
使用JUnit进行单元测试 原因 测试 断言工具类 案例一：错误冒泡排序 案例二：从数据库获取数据 @Before注解 @After JUL日志系统 使用 JUL日志 修改日志的打印级别 文件处理器 控制打印格式 日志设置过滤器 Properties配置文件 编写日志配置文件 使用Lombok快速开启日志 Mybatis日志系统
Android单元测试与日志输出
03-23
　以前做Java开发的时候用junit进行测试，利用System.out.println()方法在控制台进行打印，下面我来讲讲如何对Android应用进行单元测试以及日志输出。 　单元测试与日志输出 　1、单元测试步骤： 　第一步：在...
Mybatis3.2.7 + Oracle 10g +测试用例
06-26
- **测试框架**：通常会结合JUnit或其他测试框架编写测试用例，确保代码的正确性。 2. **数据库准备** - **创建表**：在Oracle 10g中创建名为STUDENT_USER的表，用于存储学生信息，包括ID（主键）、NAME、AGE和...
repobee-junit4：用于RepoBee的插件，该插件在克隆的存储库上运行JUnit4
02-22
然后将摘要报告打印到日志文件和终端。 默认情况下，该插件将仅报告哪些测试类别失败（以及多少测试），但是可以要求提供更详细的输出，其中包括有关每个测试失败的详细信息。 请参阅此，以更详细地了解其工作方式...
WUnit::robot:我自己的简单重新编码的JUnit
04-11
然后，WUnit调用存在@Test批注的所有方法，并根据每个结果打印日志。 我还重新编码了AssertJ库中的几种链接方法，以断言简单的测试用例。 assertThatCode() isInstanceOf() hasMessage() ...
第五次实验-龙行超-20171414631451
08-08
此外，使用调试工具或打印日志也能帮助定位问题。 总结来说，这个实验涵盖了软件测试的核心概念，包括测试用例设计、单元测试框架的使用以及在测试过程中遇到的问题及其解决策略。通过这样的测试，可以确保系统的...
android之程序调试.pdf
09-30
通过在代码中调用这些方法，可以打印出关键信息，然后在Android Studio的Logcat视图中查看，或者通过DDMS（Dalvik Debug Monitor Service）过滤和分析日志，进一步了解程序运行情况。 最后，JUnit是Java的单元测试...
详解Lombok安装及Spring Boot集成Lombok
08-26
执行JUnit测试，成功的话，日志里会有打印测试结果。 Lombok的注意点： * 在类需要序列化、反序列化时或者需要详细控制字段时，应该谨慎考虑是否要使用Lombok * 使用Lombok时，需要根据实际项目中使用的日志框架来...
Jython远程调试
05-31
1. **打印日志**：这是最基本也是最常用的调试手段，通过在代码中插入print语句，记录关键步骤的变量值和执行情况。对于那些仅在高负载或特定条件下出现的错误，日志分析尤其重要。 2. **单步跟踪**：在代码中设置...
【JavaWeb的从0到1构建知识体系（七）】JUnit和JUL日志系统
Kplusone的博客
11-12 528
JUnit和JUL日志系统
Java单元测试、日志
yqqの博客
03-12 326
JUnit是一个 Java 编程语言的单元测试工具。JUnit 是一个非常重要的测试工具概述程序中的日志可以用来记录程序在运行的时候点点滴滴。并可以进行永久存储。日志与输出语句的区别输出语句日志技术取消日志需要修改代码，灵活性比较差不需要修改代码，灵活性比较好输出位置只能是控制台可以将日志信息写入到文件或者数据库中多线程和业务代码处于一个线程中多线程方式记录日志，不影响业务代码的性能。
使用Apache Curator 结合 JUnit4 通过创建单元测试方法完成以下任务: 创建一个客户端, 连接到ZooKeeper服务器, 指定namespace为niit 为节点/foo/bar设置NodeCache缓存并添加监听, 监听事件触发则打印缓存数据相关信息 分别演示创建(递归), 修改, 删除(递归)/foo/bar节点 观察日志输出.是否可以触发NodeCache的监听事件
最新发布
05-25
首先，需要在pom.xml文件中添加Curator和JUnit4的依赖： ```xml <dependencies> <dependency> <groupId>org.apache.curator</groupId> <artifactId>curator-framework</artifactId> <version>5.1.0</version> </dependency> <dependency> <groupId>org.apache.curator</groupId> <artifactId>curator-test</artifactId> <version>5.1.0</version> <scope>test</scope> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> <scope>test</scope> </dependency> </dependencies> ``` 然后，可以编写如下的测试方法： ```java import org.apache.curator.framework.CuratorFramework; import org.apache.curator.framework.CuratorFrameworkFactory; import org.apache.curator.framework.recipes.cache.NodeCache; import org.apache.curator.framework.recipes.cache.NodeCacheListener; import org.apache.curator.retry.ExponentialBackoffRetry; import org.apache.zookeeper.CreateMode; import org.apache.zookeeper.data.Stat; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; public class CuratorTest { private static final String ZK_ADDRESS = "localhost:2181"; private static final String NAMESPACE = "niit"; private static final String PATH = "/foo/bar"; private static CuratorFramework client; private static NodeCache nodeCache; @BeforeClass public static void setUp() throws Exception { client = CuratorFrameworkFactory.builder() .connectString(ZK_ADDRESS) .retryPolicy(new ExponentialBackoffRetry(1000, 3)) .namespace(NAMESPACE) .build(); client.start(); nodeCache = new NodeCache(client, PATH); nodeCache.getListenable().addListener(new NodeCacheListener() { @Override public void nodeChanged() throws Exception { byte[] data = nodeCache.getCurrentData().getData(); Stat stat = nodeCache.getCurrentData().getStat(); System.out.println(String.format("Node data changed: %s, version: %d", new String(data), stat.getVersion())); } }); nodeCache.start(true); } @Test public void testCreate() throws Exception { String data = "hello world"; client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath(PATH, data.getBytes()); byte[] result = client.getData().forPath(PATH); assertNotNull(result); assertEquals(data, new String(result)); } @Test public void testUpdate() throws Exception { String data = "updated"; client.setData().forPath(PATH, data.getBytes()); byte[] result = client.getData().forPath(PATH); assertNotNull(result); assertEquals(data, new String(result)); } @Test public void testDelete() throws Exception { client.delete().deletingChildrenIfNeeded().forPath(PATH); Stat stat = client.checkExists().forPath(PATH); assertEquals(null, stat); } @AfterClass public static void tearDown() throws Exception { nodeCache.close(); client.close(); } } ``` 这个测试方法包含三个测试用例，分别测试了创建、修改和删除节点。在setUp()方法中，创建了一个Curator客户端和一个NodeCache实例，并注册了一个监听器，在节点数据发生变化时打印相关信息。在每个测试用例中，我们使用Curator客户端操作ZooKeeper服务器，并断言操作的正确性。在tearDown()方法中，关闭了NodeCache和Curator客户端。 这些测试用例可以通过以下命令运行： ``` mvn test ``` 如果一切正常，你应该能够看到NodeCache监听器输出的信息。也就是说，NodeCache的监听事件确实被触发了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值