SpringBoot利用AOP机制来实现日志管理，并用线程池来实现多线程日志记录的插入

最新推荐文章于 2024-06-04 11:41:50 发布
最新推荐文章于 2024-06-04 11:41:50 发布
阅读量1k 收藏 5
点赞数 2
文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43709291/article/details/127408573
版权
  1. 首先建立日志记录的实体类，和MySQL数据库对应，通过逆向工程生成实体类和mapper代码，以下就是我生成的三个实体类代码。
/**
 * @author 旺旺米雪饼
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class WebLog {
    private Long webLogId;

    private String description;

    private String username;

    private Date startTime;

    /**
     * 请求持续时间ms
     */
    private Integer durationTime;

    private String basePath;

    private String uri;

    private String url;

    private String method;

    private String ip;
}
public class WebLogExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

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


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

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


        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 andUriEqualTo(String value) {
            addCriterion("uri =", value, "uri");
            return (Criteria) this;
        }

        public Criteria andUriNotEqualTo(String value) {
            addCriterion("uri <>", value, "uri");
            return (Criteria) this;
        }

        public Criteria andUriGreaterThan(String value) {
            addCriterion("uri >", value, "uri");
            return (Criteria) this;
        }

        public Criteria andUriGreaterThanOrEqualTo(String value) {
            addCriterion("uri >=", value, "uri");
            return (Criteria) this;
        }

        public Criteria andUriLessThan(String value) {
            addCriterion("uri <", value, "uri");
            return (Criteria) this;
        }

        public Criteria andUriLessThanOrEqualTo(String value) {
            addCriterion("uri <=", value, "uri");
            return (Criteria) this;
        }

        public Criteria andUriLike(String value) {
            addCriterion("uri like", value, "uri");
            return (Criteria) this;
        }

        public Criteria andUriNotLike(String value) {
            addCriterion("uri not like", value, "uri");
            return (Criteria) this;
        }

        public Criteria andUriIn(List<String> values) {
            addCriterion("uri in", values, "uri");
            return (Criteria) this;
        }

        public Criteria andUriNotIn(List<String> values) {
            addCriterion("uri not in", values, "uri");
            return (Criteria) this;
        }

        public Criteria andUriBetween(String value1, String value2) {
            addCriterion("uri between", value1, value2, "uri");
            return (Criteria) this;
        }

        public Criteria andUriNotBetween(String value1, String value2) {
            addCriterion("uri not between", value1, value2, "uri");
            return (Criteria) this;
        }

        public Criteria andUrlIsNull() {
            addCriterion("url is null");
            return (Criteria) this;
        }

        public Criteria andUrlIsNotNull() {
            addCriterion("url is not null");
            return (Criteria) this;
        }

        public Criteria andUrlEqualTo(String value) {
            addCriterion("url =", value, "url");
            return (Criteria) this;
        }

        public Criteria andUrlNotEqualTo(String value) {
            addCriterion("url <>", value, "url");
            return (Criteria) this;
        }

        public Criteria andUrlGreaterThan(String value) {
            addCriterion("url >", value, "url");
            return (Criteria) this;
        }

        public Criteria andUrlGreaterThanOrEqualTo(String value) {
            addCriterion("url >=", value, "url");
            return (Criteria) this;
        }

        public Criteria andUrlLessThan(String value) {
            addCriterion("url <", value, "url");
            return (Criteria) this;
        }

        public Criteria andUrlLessThanOrEqualTo(String value) {
            addCriterion("url <=", value, "url");
            return (Criteria) this;
        }

        public Criteria andUrlLike(String value) {
            addCriterion("url like", value, "url");
            return (Criteria) this;
        }

        public Criteria andUrlNotLike(String value) {
            addCriterion("url not like", value, "url");
            return (Criteria) this;
        }

        public Criteria andUrlIn(List<String> values) {
            addCriterion("url in", values, "url");
            return (Criteria) this;
        }

        public Criteria andUrlNotIn(List<String> values) {
            addCriterion("url not in", values, "url");
            return (Criteria) this;
        }

        public Criteria andUrlBetween(String value1, String value2) {
            addCriterion("url between", value1, value2, "url");
            return (Criteria) this;
        }

        public Criteria andUrlNotBetween(String value1, String value2) {
            addCriterion("url not between", value1, value2, "url");
            return (Criteria) this;
        }

        public Criteria andMethodIsNull() {
            addCriterion("method is null");
            return (Criteria) this;
        }

        public Criteria andMethodIsNotNull() {
            addCriterion("method is not null");
            return (Criteria) this;
        }

        public Criteria andMethodEqualTo(String value) {
            addCriterion("method =", value, "method");
            return (Criteria) this;
        }

        public Criteria andMethodNotEqualTo(String value) {
            addCriterion("method <>", value, "method");
            return (Criteria) this;
        }

        public Criteria andMethodGreaterThan(String value) {
            addCriterion("method >", value, "method");
            return (Criteria) this;
        }

        public Criteria andMethodGreaterThanOrEqualTo(String value) {
            addCriterion("method >=", value, "method");
            return (Criteria) this;
        }

        public Criteria andMethodLessThan(String value) {
            addCriterion("method <", value, "method");
            return (Criteria) this;
        }

        public Criteria andMethodLessThanOrEqualTo(String value) {
            addCriterion("method <=", value, "method");
            return (Criteria) this;
        }

        public Criteria andMethodLike(String value) {
            addCriterion("method like", value, "method");
            return (Criteria) this;
        }

        public Criteria andMethodNotLike(String value) {
            addCriterion("method not like", value, "method");
            return (Criteria) this;
        }

        public Criteria andMethodIn(List<String> values) {
            addCriterion("method in", values, "method");
            return (Criteria) this;
        }

        public Criteria andMethodNotIn(List<String> values) {
            addCriterion("method not in", values, "method");
            return (Criteria) this;
        }

        public Criteria andMethodBetween(String value1, String value2) {
            addCriterion("method between", value1, value2, "method");
            return (Criteria) this;
        }

        public Criteria andMethodNotBetween(String value1, String value2) {
            addCriterion("method not between", value1, value2, "method");
            return (Criteria) this;
        }

        public Criteria andIpIsNull() {
            addCriterion("ip is null");
            return (Criteria) this;
        }

        public Criteria andIpIsNotNull() {
            addCriterion("ip is not null");
            return (Criteria) this;
        }

        public Criteria andIpEqualTo(String value) {
            addCriterion("ip =", value, "ip");
            return (Criteria) this;
        }

        public Criteria andIpNotEqualTo(String value) {
            addCriterion("ip <>", value, "ip");
            return (Criteria) this;
        }

        public Criteria andIpGreaterThan(String value) {
            addCriterion("ip >", value, "ip");
            return (Criteria) this;
        }

        public Criteria andIpGreaterThanOrEqualTo(String value) {
            addCriterion("ip >=", value, "ip");
            return (Criteria) this;
        }

        public Criteria andIpLessThan(String value) {
            addCriterion("ip <", value, "ip");
            return (Criteria) this;
        }

        public Criteria andIpLessThanOrEqualTo(String value) {
            addCriterion("ip <=", value, "ip");
            return (Criteria) this;
        }

        public Criteria andIpLike(String value) {
            addCriterion("ip like", value, "ip");
            return (Criteria) this;
        }

        public Criteria andIpNotLike(String value) {
            addCriterion("ip not like", value, "ip");
            return (Criteria) this;
        }

        public Criteria andIpIn(List<String> values) {
            addCriterion("ip in", values, "ip");
            return (Criteria) this;
        }

        public Criteria andIpNotIn(List<String> values) {
            addCriterion("ip not in", values, "ip");
            return (Criteria) this;
        }

        public Criteria andIpBetween(String value1, String value2) {
            addCriterion("ip between", value1, value2, "ip");
            return (Criteria) this;
        }

        public Criteria andIpNotBetween(String value1, String value2) {
            addCriterion("ip not between", value1, value2, "ip");
            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);
        }
    }
}
/**
 * @author 旺旺米雪饼
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class WebLogWithBLOBs extends WebLog {
    private String parameter;

    private String result;

}

 2.实体类所对应的mapper.java文件：

/**
 * @author 旺旺米雪饼
 */
public interface WebLogMapper {
    long countByExample(WebLogExample example);

    int deleteByExample(WebLogExample example);

    int deleteByPrimaryKey(Long webLogId);

    int insert(WebLogWithBLOBs record);

    int insertSelective(WebLogWithBLOBs record);

    List<WebLogWithBLOBs> selectByExampleWithBLOBs(WebLogExample example);

    List<WebLog> selectByExample(WebLogExample example);

    WebLogWithBLOBs selectByPrimaryKey(Long webLogId);

    int updateByExampleSelective(@Param("record") WebLogWithBLOBs record, @Param("example") WebLogExample example);

    int updateByExampleWithBLOBs(@Param("record") WebLogWithBLOBs record, @Param("example") WebLogExample example);

    int updateByExample(@Param("record") WebLog record, @Param("example") WebLogExample example);

    int updateByPrimaryKeySelective(WebLogWithBLOBs record);

    int updateByPrimaryKeyWithBLOBs(WebLogWithBLOBs record);

    int updateByPrimaryKey(WebLog record);
    int insertBatch(@Param("webLogList") List<WebLog> webLogList);
}

3.所对应的WebLogMapper.xml文件为：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjfu.mapper.WebLogMapper">
  <resultMap id="BaseResultMap" type="com.bjfu.entity.WebLog">
    <id column="web_log_id" jdbcType="BIGINT" property="webLogId" />
    <result column="description" jdbcType="VARCHAR" property="description" />
    <result column="username" jdbcType="VARCHAR" property="username" />
    <result column="start_time" jdbcType="TIMESTAMP" property="startTime" />
    <result column="duration_time" jdbcType="INTEGER" property="durationTime" />
    <result column="base_path" jdbcType="VARCHAR" property="basePath" />
    <result column="uri" jdbcType="VARCHAR" property="uri" />
    <result column="url" jdbcType="VARCHAR" property="url" />
    <result column="method" jdbcType="VARCHAR" property="method" />
    <result column="ip" jdbcType="VARCHAR" property="ip" />
  </resultMap>
  <resultMap extends="BaseResultMap" id="ResultMapWithBLOBs" type="com.bjfu.entity.WebLogWithBLOBs">
    <result column="parameter" jdbcType="LONGVARCHAR" property="parameter" />
    <result column="result" jdbcType="LONGVARCHAR" property="result" />
  </resultMap>
  <sql id="Example_Where_Clause">
    <where>
      <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>
    </where>
  </sql>
  <sql id="Update_By_Example_Where_Clause">
    <where>
      <foreach collection="example.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>
    </where>
  </sql>
  <sql id="Base_Column_List">
    web_log_id, description, username, start_time, duration_time, base_path, uri, url, 
    method, ip
  </sql>
  <sql id="Blob_Column_List">
    parameter, result
  </sql>
  <select id="selectByExampleWithBLOBs" parameterType="com.bjfu.entity.WebLogExample" resultMap="ResultMapWithBLOBs">
    select
    <if test="distinct">
      distinct
    </if>
    <include refid="Base_Column_List" />
    ,
    <include refid="Blob_Column_List" />
    from web_log
    <if test="_parameter != null">
      <include refid="Example_Where_Clause" />
    </if>
    <if test="orderByClause != null">
      order by ${orderByClause}
    </if>
  </select>
  <select id="selectByExample" parameterType="com.bjfu.entity.WebLogExample" resultMap="BaseResultMap">
    select
    <if test="distinct">
      distinct
    </if>
    <include refid="Base_Column_List" />
    from web_log
    <if test="_parameter != null">
      <include refid="Example_Where_Clause" />
    </if>
    <if test="orderByClause != null">
      order by ${orderByClause}
    </if>
  </select>
  <select id="selectByPrimaryKey" parameterType="java.lang.Long" resultMap="ResultMapWithBLOBs">
    select 
    <include refid="Base_Column_List" />
    ,
    <include refid="Blob_Column_List" />
    from web_log
    where web_log_id = #{webLogId,jdbcType=BIGINT}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Long">
    delete from web_log
    where web_log_id = #{webLogId,jdbcType=BIGINT}
  </delete>
  <delete id="deleteByExample" parameterType="com.bjfu.entity.WebLogExample">
    delete from web_log
    <if test="_parameter != null">
      <include refid="Example_Where_Clause" />
    </if>
  </delete>
  <insert id="insert" parameterType="com.bjfu.entity.WebLogWithBLOBs">
    <selectKey keyProperty="webLogId" order="AFTER" resultType="java.lang.Long">
      SELECT LAST_INSERT_ID()
    </selectKey>
    insert into web_log (description, username, start_time, 
      duration_time, base_path, uri, 
      url, method, ip, parameter, 
      result)
    values (#{description,jdbcType=VARCHAR}, #{username,jdbcType=VARCHAR}, #{startTime,jdbcType=TIMESTAMP}, 
      #{durationTime,jdbcType=INTEGER}, #{basePath,jdbcType=VARCHAR}, #{uri,jdbcType=VARCHAR}, 
      #{url,jdbcType=VARCHAR}, #{method,jdbcType=VARCHAR}, #{ip,jdbcType=VARCHAR}, #{parameter,jdbcType=LONGVARCHAR}, 
      #{result,jdbcType=LONGVARCHAR})
  </insert>
  <insert id="insertBatch">
    insert into web_log (description, username, start_time,
    duration_time, base_path, uri,
    url, method, ip, parameter,
    result)
    values
    <foreach collection="webLogList" item="item" separator=",">
      (#{item.description,jdbcType=VARCHAR}, #{item.username,jdbcType=VARCHAR}, #{item.startTime,jdbcType=TIMESTAMP},
      #{item.durationTime,jdbcType=TIMESTAMP}, #{item.basePath,jdbcType=VARCHAR}, #{item.uri,jdbcType=VARCHAR},
      #{item.url,jdbcType=VARCHAR}, #{item.method,jdbcType=VARCHAR}, #{item.ip,jdbcType=VARCHAR}, #{item.parameter,jdbcType=VARCHAR},
      #{item.result,jdbcType=VARCHAR})
    </foreach>
  </insert>
  <insert id="insertSelective" parameterType="com.bjfu.entity.WebLogWithBLOBs">
    <selectKey keyProperty="webLogId" order="AFTER" resultType="java.lang.Long">
      SELECT LAST_INSERT_ID()
    </selectKey>
    insert into web_log
    <trim prefix="(" suffix=")" suffixOverrides=",">
      <if test="description != null">
        description,
      </if>
      <if test="username != null">
        username,
      </if>
      <if test="startTime != null">
        start_time,
      </if>
      <if test="durationTime != null">
        duration_time,
      </if>
      <if test="basePath != null">
        base_path,
      </if>
      <if test="uri != null">
        uri,
      </if>
      <if test="url != null">
        url,
      </if>
      <if test="method != null">
        method,
      </if>
      <if test="ip != null">
        ip,
      </if>
      <if test="parameter != null">
        parameter,
      </if>
      <if test="result != null">
        result,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
      <if test="description != null">
        #{description,jdbcType=VARCHAR},
      </if>
      <if test="username != null">
        #{username,jdbcType=VARCHAR},
      </if>
      <if test="startTime != null">
        #{startTime,jdbcType=TIMESTAMP},
      </if>
      <if test="durationTime != null">
        #{durationTime,jdbcType=INTEGER},
      </if>
      <if test="basePath != null">
        #{basePath,jdbcType=VARCHAR},
      </if>
      <if test="uri != null">
        #{uri,jdbcType=VARCHAR},
      </if>
      <if test="url != null">
        #{url,jdbcType=VARCHAR},
      </if>
      <if test="method != null">
        #{method,jdbcType=VARCHAR},
      </if>
      <if test="ip != null">
        #{ip,jdbcType=VARCHAR},
      </if>
      <if test="parameter != null">
        #{parameter,jdbcType=LONGVARCHAR},
      </if>
      <if test="result != null">
        #{result,jdbcType=LONGVARCHAR},
      </if>
    </trim>
  </insert>
  <select id="countByExample" parameterType="com.bjfu.entity.WebLogExample" resultType="java.lang.Long">
    select count(*) from web_log
    <if test="_parameter != null">
      <include refid="Example_Where_Clause" />
    </if>
  </select>
  <update id="updateByExampleSelective" parameterType="map">
    update web_log
    <set>
      <if test="record.webLogId != null">
        web_log_id = #{record.webLogId,jdbcType=BIGINT},
      </if>
      <if test="record.description != null">
        description = #{record.description,jdbcType=VARCHAR},
      </if>
      <if test="record.username != null">
        username = #{record.username,jdbcType=VARCHAR},
      </if>
      <if test="record.startTime != null">
        start_time = #{record.startTime,jdbcType=TIMESTAMP},
      </if>
      <if test="record.durationTime != null">
        duration_time = #{record.durationTime,jdbcType=INTEGER},
      </if>
      <if test="record.basePath != null">
        base_path = #{record.basePath,jdbcType=VARCHAR},
      </if>
      <if test="record.uri != null">
        uri = #{record.uri,jdbcType=VARCHAR},
      </if>
      <if test="record.url != null">
        url = #{record.url,jdbcType=VARCHAR},
      </if>
      <if test="record.method != null">
        method = #{record.method,jdbcType=VARCHAR},
      </if>
      <if test="record.ip != null">
        ip = #{record.ip,jdbcType=VARCHAR},
      </if>
      <if test="record.parameter != null">
        parameter = #{record.parameter,jdbcType=LONGVARCHAR},
      </if>
      <if test="record.result != null">
        result = #{record.result,jdbcType=LONGVARCHAR},
      </if>
    </set>
    <if test="_parameter != null">
      <include refid="Update_By_Example_Where_Clause" />
    </if>
  </update>
  <update id="updateByExampleWithBLOBs" parameterType="map">
    update web_log
    set web_log_id = #{record.webLogId,jdbcType=BIGINT},
      description = #{record.description,jdbcType=VARCHAR},
      username = #{record.username,jdbcType=VARCHAR},
      start_time = #{record.startTime,jdbcType=TIMESTAMP},
      duration_time = #{record.durationTime,jdbcType=INTEGER},
      base_path = #{record.basePath,jdbcType=VARCHAR},
      uri = #{record.uri,jdbcType=VARCHAR},
      url = #{record.url,jdbcType=VARCHAR},
      method = #{record.method,jdbcType=VARCHAR},
      ip = #{record.ip,jdbcType=VARCHAR},
      parameter = #{record.parameter,jdbcType=LONGVARCHAR},
      result = #{record.result,jdbcType=LONGVARCHAR}
    <if test="_parameter != null">
      <include refid="Update_By_Example_Where_Clause" />
    </if>
  </update>
  <update id="updateByExample" parameterType="map">
    update web_log
    set web_log_id = #{record.webLogId,jdbcType=BIGINT},
      description = #{record.description,jdbcType=VARCHAR},
      username = #{record.username,jdbcType=VARCHAR},
      start_time = #{record.startTime,jdbcType=TIMESTAMP},
      duration_time = #{record.durationTime,jdbcType=INTEGER},
      base_path = #{record.basePath,jdbcType=VARCHAR},
      uri = #{record.uri,jdbcType=VARCHAR},
      url = #{record.url,jdbcType=VARCHAR},
      method = #{record.method,jdbcType=VARCHAR},
      ip = #{record.ip,jdbcType=VARCHAR}
    <if test="_parameter != null">
      <include refid="Update_By_Example_Where_Clause" />
    </if>
  </update>
  <update id="updateByPrimaryKeySelective" parameterType="com.bjfu.entity.WebLogWithBLOBs">
    update web_log
    <set>
      <if test="description != null">
        description = #{description,jdbcType=VARCHAR},
      </if>
      <if test="username != null">
        username = #{username,jdbcType=VARCHAR},
      </if>
      <if test="startTime != null">
        start_time = #{startTime,jdbcType=TIMESTAMP},
      </if>
      <if test="durationTime != null">
        duration_time = #{durationTime,jdbcType=INTEGER},
      </if>
      <if test="basePath != null">
        base_path = #{basePath,jdbcType=VARCHAR},
      </if>
      <if test="uri != null">
        uri = #{uri,jdbcType=VARCHAR},
      </if>
      <if test="url != null">
        url = #{url,jdbcType=VARCHAR},
      </if>
      <if test="method != null">
        method = #{method,jdbcType=VARCHAR},
      </if>
      <if test="ip != null">
        ip = #{ip,jdbcType=VARCHAR},
      </if>
      <if test="parameter != null">
        parameter = #{parameter,jdbcType=LONGVARCHAR},
      </if>
      <if test="result != null">
        result = #{result,jdbcType=LONGVARCHAR},
      </if>
    </set>
    where web_log_id = #{webLogId,jdbcType=BIGINT}
  </update>
  <update id="updateByPrimaryKeyWithBLOBs" parameterType="com.bjfu.entity.WebLogWithBLOBs">
    update web_log
    set description = #{description,jdbcType=VARCHAR},
      username = #{username,jdbcType=VARCHAR},
      start_time = #{startTime,jdbcType=TIMESTAMP},
      duration_time = #{durationTime,jdbcType=INTEGER},
      base_path = #{basePath,jdbcType=VARCHAR},
      uri = #{uri,jdbcType=VARCHAR},
      url = #{url,jdbcType=VARCHAR},
      method = #{method,jdbcType=VARCHAR},
      ip = #{ip,jdbcType=VARCHAR},
      parameter = #{parameter,jdbcType=LONGVARCHAR},
      result = #{result,jdbcType=LONGVARCHAR}
    where web_log_id = #{webLogId,jdbcType=BIGINT}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.bjfu.entity.WebLog">
    update web_log
    set description = #{description,jdbcType=VARCHAR},
      username = #{username,jdbcType=VARCHAR},
      start_time = #{startTime,jdbcType=TIMESTAMP},
      duration_time = #{durationTime,jdbcType=INTEGER},
      base_path = #{basePath,jdbcType=VARCHAR},
      uri = #{uri,jdbcType=VARCHAR},
      url = #{url,jdbcType=VARCHAR},
      method = #{method,jdbcType=VARCHAR},
      ip = #{ip,jdbcType=VARCHAR}
    where web_log_id = #{webLogId,jdbcType=BIGINT}
  </update>
</mapper>

 4.用aop实现日志记录，Joinpoint(连接点)为webLog方法，Pointcut为项目的controller包。

/**
 * @author 旺旺米雪饼
 */
@Aspect
@Component
@Order(1)
@Slf4j
public class WebLogAspect {
    /**
     * 定义切点表达式,指定通知功能被应用的范围
     */
    @Pointcut("execution(public * com.bjfu.controller.*.*(..))")
    public void webLog() {
    }

    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
    }

    /**
     * value切入点位置
     * returning 自定义的变量，标识目标方法的返回值,自定义变量名必须和通知方法的形参一样
     * 特点：在目标方法之后执行的,能够获取到目标方法的返回值，可以根据这个返回值做不同的处理
     */
    @AfterReturning(value = "webLog()", returning = "ret")
    public void doAfterReturning(Object ret) throws Throwable {
    }

    /**
     * 通知包裹了目标方法，在目标方法调用之前和之后执行自定义的行为
     * ProceedingJoinPoint切入点可以获取切入点方法上的名字、参数、注解和对象
     *
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("webLog()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        //获取当前请求对象
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        assert attributes != null;
        // TODO 从这里拿token
        HttpServletRequest request = attributes.getRequest();
        //记录请求信息
        WebLogWithBLOBs webLog = new WebLogWithBLOBs();
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        long endTime = System.currentTimeMillis();
        String urlStr = request.getRequestURL().toString();
        webLog.setBasePath(urlStr);
        webLog.setIp(IpUtil.getIpAddr(request));
        webLog.setMethod(request.getMethod());
        Object parameter = getParameter(method, joinPoint.getArgs());
        if (parameter != null) {
            webLog.setParameter(parameter.toString());
        }
        //前面是前置通知，后面是后置通知
        Object result = joinPoint.proceed();
        if (result != null) {
            webLog.setResult(result.toString());
        }
        webLog.setDurationTime((int) (endTime - startTime));
        webLog.setStartTime(new Date(startTime));
        webLog.setUri(request.getRequestURI());
        webLog.setUrl(request.getRequestURL().toString());

        // String token = jwtUtil.getToken(request);
        // if (!StringUtils.isEmpty(token)) {
        //    webLog.setUsername(jwtUtil.getId(token));
        // }
//        String userId = jwtUtil.getId(jwtUtil.getToken(request));
//        webLog.setUsername(userId);
//        log.info("{}", JSONUtil.parse(webLog));

        // 数据插入到队列
        asyncTask.insertIntoQueue(webLog);
        log.info("监听到数据{}", webLog);
        return result;
    }

    @Autowired
    private AsyncTask asyncTask;

    /**
     * 根据方法和传入的参数获取请求参数
     */
    private Object getParameter(Method method, Object[] args) {
        List<Object> argList = new ArrayList<>();
        Parameter[] parameters = method.getParameters();
        for (int i = 0; i < parameters.length; i++) {
            //将RequestBody注解修饰的参数作为请求参数
            RequestBody requestBody = parameters[i].getAnnotation(RequestBody.class);
            if (requestBody != null) {
                argList.add(args[i]);
            }
            //将RequestParam注解修饰的参数作为请求参数
            RequestParam requestParam = parameters[i].getAnnotation(RequestParam.class);
            if (requestParam != null) {
                Map<String, Object> map = new HashMap<>();
                String key = parameters[i].getName();
                if (!StringUtils.isEmpty(requestParam.value())) {
                    key = requestParam.value();
                }
                map.put(key, args[i]);
                argList.add(map);
            }
        }
        if (argList.size() == 0) {
            return null;
        } else if (argList.size() == 1) {
            return argList.get(0);
        } else {
            return argList;
        }
    }
}

 5.定义一个线程池，将插入日志操作交由其他线程去做：设置一个定时器，每将十秒将操作日志记录在一个队列中，再通过LogPersistenceServiceImpl业务类实现插入操作，线程池对队列的操作可能会并发，我用synchronized关键字修饰在方法上来保证对Queue<WebLog> DATA_QUEUE队列的操作原子性。

/**
 * @author 旺旺米雪饼
 */
@Slf4j
@Component
public class AsyncTask {

    /**
     * 线程池对队列的操作可能并发，需要用synchronized保证队列内存可见性
     */
//    public final static Queue<WebLog> DATA_QUEUE = new LinkedBlockingQueue<>();
    public final static Queue<WebLog> DATA_QUEUE = new LinkedList<>();
    private final List<WebLog> logList = new ArrayList<>();
    @Autowired
    private LogPersistenceServiceImpl logPersistenceServiceImpl;

    private synchronized void commitLogPool() {
        while (DATA_QUEUE.peek() != null) {
            int size = DATA_QUEUE.size();
            logList.clear();
            for (int i = 0; i < size; i++) {
                logList.add(DATA_QUEUE.poll());
            }
            int affectRows = logPersistenceServiceImpl.insertBatch(logList);
            logList.clear();
            log.info("共有{}条日志插入成功", affectRows);
        }

    }

    @Async("asyncExecutor")
    public synchronized void insertIntoQueue(WebLog webLog) {
        log.info("线程池接收到数据");
        DATA_QUEUE.offer(webLog);
    }

    /**
     * 每10秒将用户的擦欧哦日志刷新到数据库
     */
    @Scheduled(cron = "0/10 * * * * ? ")
    public void timer() {
        log.info("用户的操作日志刷新到数据库，共有条记录{}", logList.size());
        //spring timer定时提交任务
        commitLogPool();
    }
}

6.同样， 线程池定义如下：定义了核心线程数，最大线程数，空闲线程存活时间，并且采用ThreadPoolTaskExecutor();方式建立线程。

/**
 * 启用 Spring 的异步方法执行功能
 *
 * @author 旺旺米雪饼
 */
@EnableAsync
@Configuration
public class ExecutorConfig {


    // new ThreadPoolTaskExecutor();
    /**
     * 核心线程数量，默认16
     */
    private final static int CORE_POOL_SIZE = 16;

    /**
     * 最大线程数量，默认Integer.MAX_VALUE;
     */
    private final static int MAX_POLL_SIZE = 32;

    /**
     * 空闲线程存活时间
     */
    private final static int KEEP_ALIVE_SECONDS = 60;

    /**
     * 线程阻塞队列容量,默认Integer.MAX_VALUE
     */
    private final static int QUEUE_CAPACITY = 10;

    /**
     * 是否允许核心线程超时
     */
    private final static boolean ALLOW_CORE_THREAD_TIMEOUT = false;


    @Bean("asyncExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 配置核心线程数量
        executor.setCorePoolSize(CORE_POOL_SIZE);
        // 配置最大线程数
        executor.setMaxPoolSize(MAX_POLL_SIZE);

        // 配置队列容量
        executor.setQueueCapacity(QUEUE_CAPACITY);
        // 配置空闲线程存活时间
        executor.setKeepAliveSeconds(KEEP_ALIVE_SECONDS);

        executor.setAllowCoreThreadTimeOut(ALLOW_CORE_THREAD_TIMEOUT);

        // 设置拒绝策略，直接在execute方法的调用线程中运行被拒绝的任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());

        // 执行初始化
        executor.initialize();
        return executor;
    }
}

7.业务类实现接口：

/**
 * @author 旺旺米雪饼
 * 日志表操作业务类
 */
@Service
public class LogPersistenceServiceImpl {
    @Resource
    private WebLogMapper webLogMapper;

    public int insertBatch(List<WebLog> webLogList) {
        return webLogMapper.insertBatch(webLogList);
    }
}

 别忘了在application中加@EnableAsync和@EnableScheduling注解。

旺旺米雪饼
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot基于AOP将web请求写入日志
11-25
灰常简单,适合新手,一看就懂,本来就是新手写的
springboot AOP记录日志（线程池实现）
n009ww的博客
11-01 2783
通过线程池异步实现的目的是，尽量不去抢占主业务的资源，通过异步线程处理切面日志 1.配置多线程执行器 @Configuration @EnableAsync public class ExecutorConfig { @Bean public Executor asyncServiceExecutor() { ThreadPoolTaskExec...
Spring Boot 使用自定义注解和自定义线程池实现异步日志记录
最新发布
傲泣龙腾的博客
06-04 4655
通过`自定义注解`、`Spring AOP` 和`自定义线程池`，我们可以在 `Spring Boot` 应用中实现高效的异步日志记录。这种方法不仅提高了日志记录的灵活性，还能减小对主业务线程的影响。希望本文对您在实际项目中实现日志记录有所帮助。这种方式在实际生产环境中非常实用，特别是在需要高效处理大量日志记录的场景下。通过合理配置线程池，可以确保日志记录的性能和稳定性。
SpringBoot使用AOP统一处理日志
weixin_43890927的博客
06-28 1158
查看数据 http://127.0.0.1:8080//api/logs/list。准备sys_log日志表（mysql）2.2 annotation包。2.4 aspect包（核心）Action 日 志 分 类。Log 实现 Aop 切面类。SysLog（日志模型）2.1 domain包。2.3 common包。
SpringBoot 中异步多线程的MDC日志跟踪
清泉影月
09-03 3293
SpringBoot 如果不涉及异步多线程日志跟踪相对简单，可以参考logback + MDC 搭建 springboot 的日志系统，如果涉及异步多线程就需要重写线程池，线程池有很多方法，其实没必要都重写，只要把提交线程的方法重写即可。
Spring Boot-AOP日志管理
weixin_45977186的博客
03-18 1061
AOP Spring的两大核心之一的AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论，是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。是一种通过动态代理实现程序功能扩展和统一维护的一种技术。 本篇介绍通过使用AOP，在进行接口调用时根据其访问的控制层方法打印对应的请求日志，例如：调用接口，客户端浏览器型号，电脑系统型号， 方法执行时间，请求参数等等。 AOP的相关术语 横切关注点 从每个方法中抽取出来的同一类非
详解基于SpringBoot使用AOP技术实现操作日志管理
08-25
例如，日志管理就是一个切面，它在多个类的多个方法中插入日志记录代码。 2. **Join point（连接点）**：程序执行的特定点，如方法的执行。在Spring中，连接点通常是方法调用。 3. **Advice（通知）**：在特定连接...
springBoot+aop+自定义注解+本地线程实现统一接口日志及接口响应时长
02-01
内容概要：springboot+拦截器+aop+自定义注解+本地线程实现统一接口日志记录，记录下接口所在模块、接口描述、接口请求参数、接口返回参数、接口请求时间以及接口耗时用于接口优化，接口记录参数以及操作人防止使用...
使用SpringBoot+AOP实现可插拔式日志的示例代码
08-25
使用 SpringBoot+AOP 实现可插拔式日志的示例代码 本文主要介绍了使用 SpringBoot 与 AOP 实现可插拔式日志的示例代码，通过示例代码详细介绍了使用 AOP 实现可插拔式日志的步骤和实现方式。 首先，AOP（Aspect-...
SpringBoot使用AOP注解记录操作日志
04-30
本篇文章将深入探讨如何在Spring Boot中利用AOP注解来实现操作日志的记录。 首先，我们需要理解AOP的基本概念。AOP允许我们定义“切面”，这些切面可以在特定的“连接点”（如方法调用）上执行自定义的行为，如日志...
java使用动态代理来实现AOP(日志记录)的实例代码共6
10-29
Java动态代理是Java编程中一个非常重要的特性，它允许我们在运行时创建代理对象，这些代理对象可以代替原对象执行某些额外的操作，例如日志记录、性能监控、事务管理等，这些都是面向切面编程（AOP）的核心应用场景...
Spring Aop打印操作日志并通过线程池同步到数据库
weixin_44745208的博客
07-25 628
实现情况展示 console打印 数据库记录 实现思路 基于Aop切面思想： ①自定义注解 ②定义一个Aspect类，定义切点 @Pointcut 目的是在注解的位置切入代码，从切面织入点处通过反射机制获取织入点处的方法，获取切入点所在方法、请求的类名、方法名、参数等 ③创建实体类，阿巴阿巴。。。把数据写入到数据库。 ④这里使用线程池，对实际的情况做了优化，当用户在执行某些操作时，如查看列表、删除数据等，需要读写数据库，然而实际记录日志的过程也要把数据写入数据库，需要耗时，而且如果日志数据写入失败还有可能
SpringBoot自定义注解+异步+观察者模式实现业务日志异步入库
mry6的博客
04-14 1719
前言基础环境导入依赖编写yml配置数据库设计代码实现实体类编写注解业务类型枚举编写切片ip工具类事件发布监听者Controller控制层servicemapper验证我们在企业级的开发中，必不可少的是对日志的记录，实现有很多种方式，常见的就是基于AOP+注解进行保存，但是考虑到程序的流畅和效率，我们可以使用异步进行保存，最近在spring和springboot源码中看到有很多的监听处理贯穿前后：这就是著名的观察者模式！！
SpringCloud 网关实现线程池异步批量保存请求日志
欢迎来到我的博客
07-22 452
*** 访问日志Service类*/@Service@Mapper然后启动项目，访问接口数据，就可以自动记录到数据库中对应的 sql：) ENGINE=InnoDB AUTO_INCREMENT=25 DEFAULT CHARSET=utf8 COMMENT='日志记录表';最后就是源码了：https://gitee.com/android.long/spring-cloud-biglead/tree/master/biglead-api-11-admin。
Springboot通过AOP和Async实现异步日志入库
Meta39的博客
10-27 2835
Springboot通过AOP和Async实现异步日志入库
使用Spring Boot AOP实现日志记录
一名想当程序员的人
07-30 3522
1.1 什么是AOPAOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一（两外两个：IOC-控制反转、DI-依赖注入）。那么AOP为何那么重要呢？在我们的程序中，经常存在一些系统性的需求，比如权限校验、日志记录、统计等，这些代码会散落穿插在各个业务逻辑中，例如下面这个示意图：有多少业务操作，就要写多少重复的校验和日志记录代码，这显然是无法接受的。
Slf4j + Log4j2 + Mongodb 日志收集
u011420410的博客
09-11 855
slf4j + Log4j2 + mongodb springboot 日志收集 添加项目依赖 项目是基于　springboot 2.0+进行的，　在低版本没有测试过 pom.xml slf4j log4j依赖添加 <!-- log out --> <dependency> <groupId>org.slf4j&...
Springboot AOP 异步操作说明
酸奶盖儿的博客
12-02 767
1. 异步场景分析 在开发系统的过程中，通常会考虑到系统的性能问题，提升系统性能的一个重要思想 就是“串行”改“并行”。说起“并行”自然离不开“异步”，今天我们就来聊聊如何使用 Spring的 @Async的异步注解。 2. Spring 业务的异步实现 2.1 启动异步配置 在基于注解方式的配置中，借助@EnableAsync注解进行异步启动声明，Spring Boot版的项目中，将@EnableAsync注解应用到启动类上， 代码示例如下： @EnableAsync //spring容器启动时会创建线程
SpringBoot-AOP日志管理
qq_34797933的博客
12-13 185
SpringBoot-AOP日志管理 一 AOP几个重要概念 Aspect：切面，在Spring中意为所有通知方法所在的类。 Join point：连接点，程序执行中的一点，在Spring中只表示方法执行（Spring只支 持方法级别的拦截） Advice：通知，在特定连接点上采取的操作，Spring将通知抽象为拦截器，并围绕连接点维护拦截器链。共有5种类型。 前置通知(@Before...
springboot aop记录日志
03-17
Spring Boot AOP 是 Spring 框架中的一种面向切面编程技术，可以在不修改源代码的情况下给应用程序添加全局的功能，如日志记录。使用 AOP 可以将日志记录功能独立出来，并且可以在不同的地方重用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值