Damon_Zhang
- 浏览: 71886 次
- 性别:
- 来自: 北京
-
文章分类
最新评论
-
juedui0769：
都是思维导图么？
JAVA IO 回顾 -
Damon_Zhang：
weir2009 写道SessionFactory是二级缓存， ...
hibernate缓存机制 -
weir2009：
SessionFactory是二级缓存，这样说对吗？
hibernate缓存机制 -
Damon_Zhang：
jjhpeopl 写道内容不错，就是spring中的bean， ...
java 单例模式及运用 -
jjhpeopl：
内容不错，就是spring中的bean，对于每个线程都是用的t ...
java 单例模式及运用
一、写前唠叨
最近写了一个关于将对象通过log4j的形式保存到数据库的例子，因对这个log4j正在入门，所以做之前查过很多资料，不过网上的信息比较简单，如下：
1.所有信息几乎全部在配置文件中进行获取，如：数据库相关的连接、用户名、密码、sql语句；日志相关的appender、输出、格式化、参数；
2.写到数据库中的仅是一个字符串而不是一个对象，如：将一个对象本身以及它的各个数据作为一条记录存到数据库
3.代码的灵活性较低，如：只能存比较简单的数据类型，如保存一个对象及属性的话，就不太容易做了。
当然，网上的这些资料当然是为了最基础的入门而做的，因此简单了些，但也不乏比较深奥的资料，比如穿件连接池，考虑缓存等等。。
二、我的做法
1.通过继承JDBCAppender实现日志的写入的
2.通过JDBC连接数据库（也可通过HIBERNATE）
3.数据库和log4j的基本信息配置到properties中，但数据库可以自由选择多种数据库（在配置文件中配置即可）
4.将对象的属性存到库中
三、项目例子
1.项目结构图：见附件，项目结构图.png
2. 数据库：MYSQL 库名：LOG4J 表名：LogMessage/StudentMessage
表结构请看附件：LogMessage.png/StudentMessage.png
3.代码及说明
log4j.properties :分别输出指定为：控制台、文件（log.log）、数据库
log4j.rootLogger=INFO,appender1,appender2,DATABASE
# console
log4j.appender.appender1=org.apache.log4j.ConsoleAppender
log4j.appender.appender1.layout=org.apache.log4j.PatternLayout
log4j.appender.appender1.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss:SSS}[%p]: %m%n
# file
log4j.appender.appender2=org.apache.log4j.FileAppender
log4j.appender.appender2.File=log.log
log4j.appender.appender2.layout=org.apache.log4j.PatternLayout
log4j.appender.appender2.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss:SSS}[%p]: %m%n
#mysql dbappender test
log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
log4j.appender.DATABASE.URL=jdbc:mysql://127.0.0.1:3306/LOG4J
log4j.appender.DATABASE.username=root
log4j.appender.DATABASE.password=root
log4j.appender.DATABASE=control.DbAppender
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n %L
Conorl包——DbAppender.java :日志提交中转站，提取日志信息，处理后进行数据库操作插入对应的表中
package control;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import org.apache.log4j.jdbc.JDBCAppender;
import org.apache.log4j.spi.ErrorCode;
import org.apache.log4j.spi.LoggingEvent;
import bean.HashMapping;
import bean.Students;
import bean.UserBean;
import dao.JdbcUtils;
import dao.StudentsUtil;
import dao.UserUtil;
public class DbAppender extends JDBCAppender {
protected void closeConnection(Connection con) {
// TODO Auto-generated method stub
// super.closeConnection(con);
JdbcUtils.close(con);
}
@Override
protected void execute(String sql) throws SQLException {
// TODO Auto-generated method stub
// super.execute(arg0);
int flag = 0;
int end = sql.lastIndexOf(")");
String sqls = sql.substring(0, end + 1);
String beanname = sql.substring(end + 1);
if (beanname.equals("UserBean")) {
flag = UserUtil.insertUser(sqls);
} else if (beanname.equals("Students")) {
flag = StudentsUtil.insertStudent(sqls);
}
System.out.println(flag == 0 ? "insert fail!" : "insert successful!");
}
@Override
protected Connection getConnection() throws SQLException {
// TODO Auto-generated method stub
// return super.getConnection();
if (connection == null) {
connection = JdbcUtils.getConnection();
}
return connection;
}
@Override
protected String getLogStatement(LoggingEvent event) {
// TODO Auto-generated method stub
// return super.getLogStatement(event);
StringBuffer sbuf = new StringBuffer();
Hashtable hm = (Hashtable) event.getMessage();
String sql = null;
if ((hm.get("beanname")).equals("UserBean")) {
sbuf.append(UserUtil.insertSql());
sql = sbuf.toString();
int end = sql.lastIndexOf("(");
sql = sql.substring(0, end) + "('" + hm.get(HashMapping.USER_TIME)
+ "','" + event.getMessage() + "','"
+ hm.get(HashMapping.USER_USERNAME) + "','"
+ hm.get(HashMapping.USER_PASSWORD) + "')";
System.out.println(sql);
return sql + hm.get("beanname");
} else if ((hm.get("beanname")).equals("Students")) {
sbuf.append(StudentsUtil.insertSql());
sql = sbuf.toString();
int end = sql.lastIndexOf("(");
sql = sql.substring(0, end)
+ "('"
+ hm.get(HashMapping.STUDENT_NAME)
+ "','"
+ hm.get(HashMapping.STUDENT_AGE)
+ "','"
+ (((Integer) (hm.get(HashMapping.STUDENT_SEX))) == 1 ? "F"
: "M") + "','" + hm.get(HashMapping.STUDENT_TIME)
+ "')";
System.out.println(sql);
return sql + hm.get("beanname");
}
return sql;
}
}
Bean包中的类——HashMapping.java ：将属性设置成常量（即键-值对中的键），便于代码中进行键值对的读取。
package bean;
public class HashMapping {
public static final String USER_USERNAME = "username";
public static final String USER_PASSWORD = "password";
public static final String USER_TIME = "time";
public static final String STUDENT_NAME = "name";
public static final String STUDENT_AGE = "age";
public static final String STUDENT_SEX = "sex";
public static final String STUDENT_TIME = "time";
}
Bean包中的类——UserBean.java/Students.java: 对LogMessage/studentMessage表及此对象持久化
package bean;
public class Students {
private String name;
private int age;
private int sex;
private String time;
public String getTime() {
return time;
}
public void setTime(String time) {
this.time = time;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
}
//===============================================
package bean;
import java.sql.Date;
public class UserBean {
private String username;
private String password;
private String Time;
private String Note;
public String getTime() {
return Time;
}
public void setTime(String time) {
Time = time;
}
public String getNote() {
return Note;
}
public void setNote(String note) {
Note = note;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
Dao中的包——GetObject.java: 将对象放到hashtable中并发送到dbappender中
package dao;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Hashtable;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import test.Test;
import bean.Students;
import bean.UserBean;
public class GetObject {
private Logger logger = Logger.getLogger(GetObject.class);
private UserBean ub;
private Students st;
private SimpleDateFormat sf;
// 保存对象
public UserBean insertInfo(String username, String password) {
ub = new UserBean();
ub.setUsername(username);
ub.setPassword(password);
return ub;
}
public Logger getLogger() {
return logger;
}
public void setLogger(Logger logger) {
this.logger = logger;
}
public UserBean getUb() {
return ub;
}
public void setUb(UserBean ub) {
this.ub = ub;
}
public Students getSt() {
return st;
}
public void setSt(Students st) {
this.st = st;
}
public SimpleDateFormat getSf() {
return sf;
}
public void setSf(SimpleDateFormat sf) {
this.sf = sf;
}
public Students insertInfo(String name, int age, int sex) {
st = new Students();
st.setName(name);
st.setAge(age);
st.setSex(sex);
return st;
}
// bean key-value
public void getMethod(Object obj) {
sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
PropertyConfigurator.configure("log4j.properties");
Hashtable ht = new Hashtable();
ht.clear();
if (obj instanceof UserBean) {
ht.put("username", ub.getUsername());
ht.put("password", ub.getPassword());
ht.put("time", sf.format(new Date()));
ht.put("beanname", "UserBean");
} else if (obj instanceof Students) {
ht.put("name", st.getName());
ht.put("age", st.getAge());
ht.put("sex", st.getSex());
ht.put("time", sf.format(new Date()));
ht.put("beanname","Students");
}
logger.info(ht);
}
}
Dao中的包——JdbcUtils.java: 数据库的动态链接
package dao;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
public final class JdbcUtils {
//
private static String url = null;
private static String driver = null;
private static String username = null;
private static String password = null;
private JdbcUtils() {
}
static{
try {
getProperties();
Class.forName(driver);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url, username, password);
}
public static void close(Connection conn) {
try {
if (conn != null)
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void getProperties() {
Properties props = new Properties();
FileInputStream istream = null;
try {
istream = new FileInputStream("log4j.properties");
props.load(istream);
Set s = props.keySet();
Iterator it = s.iterator();
while (it.hasNext()) {
String id = (String) it.next();
String value = props.getProperty(id);
if(id.equals("log4j.appender.DATABASE.driver")){
driver = value;
}else if(id.equals("log4j.appender.DATABASE.URL")){
url = value;
}else if(id.equals("log4j.appender.DATABASE.username")){
username = value;
}else if(id.equals("log4j.appender.DATABASE.password")){
password = value;
}
// System.out.println(id + ":=" + value);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
istream.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
Dao中的包——StudentsUtil.java/UserUtil.java: 对各自的表进行数据库的操作
package dao;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
public class StudentsUtil {
public static int insertStudent(String sql) {
Connection conn = null;
Statement sm = null;
int flag = 0;
try {
conn = JdbcUtils.getConnection();
sm = conn.createStatement();
sm.execute(sql);
flag = 1;
} catch (SQLException e) {
// TODO Auto-generated catch block
System.out.println("insert fail!");
} finally {
if (sm != null) {
try {
sm.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
JdbcUtils.close(conn);
}
return flag;
}
public static String insertSql() {
return "INSERT INTO StudentMessage(Name,Age,Sex,Time) values(";
}
}
//===============================================
package dao;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import bean.UserBean;
public class UserUtil {
public static int insertUser(String sql) {
Connection conn = null;
Statement sm = null;
int flag = 0;
try {
conn = JdbcUtils.getConnection();
sm = conn.createStatement();
sm.execute(sql);
flag = 1;
} catch (SQLException e) {
// TODO Auto-generated catch block
System.out.println("insert fail!");
} finally {
if (sm != null) {
try {
sm.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
JdbcUtils.close(conn);
}
return flag;
}
public static String insertSql(){
return "INSERT INTO LogMessage(Time,Note,Username,Password) values(";
}
}
test包——test.java :测试类
package test;
import java.lang.reflect.InvocationTargetException;
import org.apache.log4j.Logger;
import org.apache.log4j.MDC;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.jdbc.JDBCAppender;
import org.omg.CORBA.Request;
import dao.GetObject;
import bean.Students;
import bean.UserBean;
public class Test {
public static void main(String[] args) {
Test dbt = new Test();
dbt.testUser();
}
public void testUser() {
try {
GetObject go = new GetObject();
UserBean ub = go.insertInfo("EE-YY", "YY-12345");
go.getMethod(ub);
// Students st = go.insertInfo("YY", 21, 2);
// go.getMethod(st);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
结果见附加：stuM.png/logM.png
1
顶
顶
0
踩
踩
分享到：
发表评论
-
CXF 生成客户端报错 Two classes have the same XML type name
2013-02-27 19:18 5282原文链接：http://damonshell.si ... -
OSGI之 Eclipse 插件使用OSGI
2012-04-13 10:38 2710由于工作需要，下午花了点时间仔细了解了一下OSGI和如 ... -
OSGI之 Eclipse 插件使用OSGI
2012-04-12 17:59 7由于工作需要，下 ... -
ant 简述及build.xml
2012-04-11 17:54 1132一、ant 简述 1,什么是ant ant是构建工具 2,什么 ... -
JAVA 解析XML (learn from WSZ)
2012-03-05 18:06 886想想工作这大半年 ... -
log4j 使用
2012-02-27 12:48 8661.log4j ,顾名思义，log for ...
相关推荐
本文将详细介绍如何在Java中使用Log4j来记录日志，并将其写入数据库。 首先，我们需要了解Log4j的基本结构。一个简单的Log4j项目通常包含以下几个部分： 1. **配置文件**：Log4j的配置文件通常是`log4j.properties...
在我们的示例中，我们关注的是如何配置Log4j2以将日志写入MySQL数据库。首先，我们需要在`log4j2.xml`配置文件中定义一个使用JDBC Appender的配置： ```xml <JDBC name="DatabaseAppender" tableName="logs"> ...
然后，在Java代码中，我们可以创建并使用Logger对象，Log4j会自动将日志信息写入数据库。例如： ```java import org.apache.log4j.Logger; public class LogDemo { private static final Logger logger = Logger....
在“log4j日志写入数据库实例”中，我们将关注如何配置Log4j将日志信息存储到数据库中，以便于后期分析和检索。 要实现这个功能，我们需要创建一个Appender，该Appender能够与数据库进行交互。通常，我们会使用...
Log4j的核心优势在于其可配置性，可以根据不同的需求将日志输出到控制台、文件、数据库甚至网络上。 在"log4j添加日志到数据库和文件中"的场景中，我们首先需要理解Log4j的基本架构。它主要由三个组件构成：Logger...
- `log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/log4j`：连接数据库的URL。 - `log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver`：MySQL驱动类。 - `log4j.appender.DATABASE.user=root`：...
在学习Log4j的过程中，阅读“log4j学习笔记及写入数据库配置”这份资料将有助于深入理解Log4j的使用，包括具体的配置步骤、常见问题以及最佳实践。通过实践，你可以更好地掌握如何利用Log4j来提升你的应用程序的可...
这篇博客“使用log4j记录日志到数据库”将介绍如何配置和使用Log4j，以便将日志信息存储到数据库中，而非传统的文本文件。数据库存储的日志便于进行结构化查询，有助于进行长期的数据分析和管理。 首先，理解Log4j...
2. **Log4j配置**：要将日志输出到数据库，需要在`log4j.properties`或`log4j.xml`配置文件中添加一个Appender，指定为JDBC类型。配置包括数据库连接信息（如URL、用户名、密码）、SQL语句（插入日志记录）等。 3. ...
本教程将详细介绍如何配置Log4j以使用DBCP连接池，并将日志信息存储到MySQL数据库中。 首先，我们需要在项目中引入Log4j和DBCP的相关依赖。对于Maven项目，可以在pom.xml文件中添加如下依赖： ```xml ...
在Java应用程序中，log4j允许开发者定义多个日志级别（如DEBUG、INFO、WARN、ERROR等），并决定在何时何地将这些日志信息写入不同的输出目的地，如控制台、文件、电子邮件或者syslog服务器。这个压缩包中的log4j jar...
Log4j允许我们直接将日志信息存储到数据库中，这对于需要长期保存和分析大量日志数据的系统来说尤其有用。首先，你需要配置一个Appender（输出端），例如使用JDBCAppender。在配置文件中，定义数据库连接参数，包括...
在Eclipse中，右键点击项目 -> "Build Path" -> "Configure Build Path" -> "Libraries" -> "Add External JARs"，然后选择MyBatis的jar文件，包括mybatis-x.x.x.jar和mybatis-logging的相应实现（如log4j）。...
一旦配置完成，你就可以在Kettle的工作流或转换中创建步骤来读取、写入或操作MySQL数据库中的数据。这包括但不限于表输入、表输出、SQL步骤、JOIN步骤等，这些都极大地丰富了数据处理的可能性。 使用Kettle进行ETL...
通过JDBC，Java应用程序可以与多种类型的数据库进行交互，实现数据的读取、写入等功能。批量操作是指在一次数据库连接中执行多次SQL语句的操作，这种方式能显著提高程序性能，尤其是在处理大量数据时。 **批量插入*...
在某些情况下，日志可能会被写入数据库，这需要配置Log4j以使用JDBC Appender。这将使日志信息存储在数据库表中，便于管理和分析。 配置Log4j使用JDBC Appender通常涉及以下步骤： a. 添加Log4j和JDBC相关的依赖...
9. `commons-logging-1.2.jar`：Apache Commons Logging是日志服务的抽象层，允许开发者选择不同的日志实现，如Log4j或Java内置的日志API。在数据库操作中，日志记录对于调试和问题排查至关重要。 这些组件结合在...
在Java开发中，当需要向MySQL数据库大量插入数据时，使用JDBC的批量处理功能可以显著提高效率。本文将详细讲解如何使用JDBC批量插入10万条数据，并探讨其背后的原理和优化策略。 批量处理在JDBC中主要通过Statement...
9. **slf4j-api*.jar** 和 **slf4j-log4j12*.jar**: 日志记录框架SLF4J和其适配器Log4j，用于记录Hive JDBC操作的日志信息。 10. **protobuf*.jar**: Protocol Buffers是Google的一种数据序列化协议，Hive可能用它...