认真去做一件事，总会有所收获的

使用hibernate如何进行数据持久化，

在这里我首先需要的是把各个pojo的数据进行xml配置，如下

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.lxh.entity.Manager" table="manager"  catalog="bbs">
        <id name="managerId" type="java.lang.Integer">
            <column name="managerId" />
            <generator class="native" />
        </id>
        <property name="managerName" type="java.lang.String">
            <column name="managerName" length="16" not-null="true" />
        </property>
        <property name="managerPassword" type="java.lang.String">
            <column name="managerPassword" length="12" not-null="true" />
        </property>
    </class>
</hibernate-mapping>
``` 
需要给出数据库名字和表，然后由hibernate进行数据的转换，确定对应的关系，封装了数据然后传递给数据库进行交互，然后就是配置该个数据的连接数据，在之中配置账号和密码等信息，现在市面有很多的数据封装，druid和c3po就是对数据进行了封装。在数据传输会有办法进行对数据库的加密，这个下一个方面会提到，这里给出对数据的配置
```java
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
		<property name="connection.username">root</property>
		<property name="connection.url">
			jdbc:mysql://localhost:3306/bbs
		</property>
		<property name="dialect">
			org.hibernate.dialect.MySQLDialect
		</property>
		
		<property name="connection.password">root</property>
		<property name="connection.driver_class">
			com.mysql.jdbc.Driver
		</property>
		<mapping resource="com/lxh/entity/Manager.hbm.xml" />
		<mapping resource="com/lxh/entity/Question.hbm.xml" />
		<mapping resource="com/lxh/entity/User.hbm.xml" />
	</session-factory>
</hibernate-configuration>

在这里配置了数据驱动和账号密码等信息。然后接下来就是对数据进行封装和持久化，这样就有下面的配置，这是使用了SessionFactory和configuration对配置文件进行读取，然后就是对dao的配置和使用啦，这里要提到的是在这个过程中可以使用加密算法的使用，这里我也找了一个加密的算法进行简单的书写，号直接来看过程

package com.lxh.dao;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.lxh.config.HibernateSessionFactory;
import com.lxh.entity.Manager;
import com.lxh.entity.Question;
import com.lxh.entity.User;
@SuppressWarnings("deprecation")
public class ManagerDaoImpl extends UserDaoImpl implements ManagerDao {
	private Session session;
	
	private Query query;
	private Transaction transaction;
	@SuppressWarnings("unchecked")
	@Override
	public Manager judgeManager(Manager manager) {
		Manager manager2 = null;
		session = HibernateSessionFactory.getSession();
		String hql = "from Manager as manager where manager.managerName = ? and manager.managerPassword = ?";
		query = session.createQuery(hql);
		query.setString(0, manager.getManagerName());
		query.setString(1, manager.getManagerPassword());
		Iterator<Manager> iterator = query.list().iterator();
		if(iterator.hasNext()){ 
			manager2 = iterator.next();
		}
		session.close();
		return manager2;
	}
	@Override
	public void saveManager(Manager manager) {
		session=HibernateSessionFactory.getSession();
		transaction=session.beginTransaction();
		session.save(manager);
		transaction.commit();
		session.close();
		
	}
	
	@Override
	public int QuestionAmount() {
		int questionAmount = 0;
		session = HibernateSessionFactory.getSession();
		String hql = "select count(*) from Question";
		query = session.createQuery(hql);
		long  l = (Long)query.uniqueResult();
		questionAmount = (int)l;
		session.close();
		return questionAmount;
		
	}
	@SuppressWarnings("unchecked")
	@Override
	public List<Question> allQuestion(int pageNumber, int pageSize) {
		session = HibernateSessionFactory.getSession();
		List<Question> allQuestion = new ArrayList<Question>();
		String hql = "from Question as question order by question.postTime desc";
		query = session.createQuery(hql);
		query.setFirstResult((pageNumber - 1)*pageSize);
		query.setMaxResults(pageSize);
		allQuestion = query.list();
		session.close();
		return allQuestion;
	}
	@Override
	public User findUser(int userId) {
		
		session=HibernateSessionFactory.getSession();
		User user=(User)session.get("com.lxh.entity.User", userId);
		
		session.close();
		return user;
	}
	
	@Override
	public void deleteQuestion(Question question) {
		session = HibernateSessionFactory.getSession();
		transaction = session.beginTransaction();
		session.delete(question);
		transaction.commit();
		session.close();
	}
	
	
	/**分页,返回当前页数和总页数*/
	public int[] pageNumber(int questionAmount,String pageNumberStr,int pageSize){
		int[] paging = new int[2];
		int pageNumber = 1;
		pageNumber = Integer.parseInt(pageNumberStr);
		if(pageNumber <= 0){
			pageNumber = 1;
		}
		int totalPage = 1;
		if(questionAmount > 0){
			totalPage = questionAmount%pageSize==0?(questionAmount/pageSize):(questionAmount/pageSize+1);
		}
		if(pageNumber > totalPage){
			pageNumber = totalPage;
		}
		paging[0] = pageNumber;
		paging[1] = totalPage;
		return paging;
	}
}

当然在一个显示的过程中，分页的操作是必不可少的，这样简单的数据持久层就已经完成了，不过还需要一些其他的完善，这个你写一个demo慢慢去体会。这就是我搭建的一个论坛的一些简单的持久化代码，这也是最近几天特训老师说的一些知识，希望对你有帮助吧。

加密工具类

加密是表单查询必不可少的，这个是从github上看到的，侵权必删，下面就是

package com.vote.service;
import java.security.MessageDigest;
public class MD5Util {
	/**
	 * 密码加密
	 * @param inStr
	 * @return
	 * @throws Exception
	 */
	public static String MD5Encrypt(String inStr) throws Exception {
		MessageDigest md = MessageDigest.getInstance("MD5"); // 可以选中其他的算法如SHA
		byte[] digest = md.digest(inStr.getBytes()); // 返回的是byet[]，要转化为String存储比较方便
		String outStr = byteToString(digest);
		return outStr;
	}
	/**
	 * byteToString
	 * @param digest
	 * @return
	 * @throws Exception
	 */
	private static String byteToString(byte[] digest) throws Exception {
		String str = "";
		String tempStr = "";
		StringBuffer sb = new StringBuffer("");
		for (int i = 1; i < digest.length; i++) {
			tempStr = (Integer.toHexString(digest[i] & 0xff));
			if (tempStr.length() == 1) {
				sb.append("0");
				sb.append(tempStr);
			} else {
				sb.append(tempStr);
			}
		}
		str = sb.toString().toUpperCase();
		return str;
	}
}

总结

在这里确实学到很多在学校里学不到的东西，不过这里的环境就不说啦，总之自己考量，在这里让我考虑和认识了另一个社会和自己。

Sep 5

策略模式

jdbc的定义

JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。

##jdbc的基本连接
简单的说就是加载驱动，建立连接，然后进行查询和删除等语句的操作，在java中提供了java.sql的jar包，不过我现在用的是mysql的连接和实例，在这里基本在本地的服务器都是用到下面这个语句

Class.forName("com.mysql.jdbc.Driver");
		String url="jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8";
		String user="root";
		String password="root";

加载和建立连接，这就是基本的一个语法结构，在连接数据库当然还有其他的属性可以设置，比如说最大的连接数了，和如何建立连接池，都可以在配置中用到，这里我就简单的介绍如何连接，后面跟的是这个连接的字符集，防止出现乱码

简单的增删改查

简单的增删改查是每个开发者都会遇到的，毕竟我们整个系统真正的业务所在也是这几个简单的逻辑，但是在关系的连接和耦合性下就会变成复杂百倍的系统，所以要懂得基本的就可以窥见更大系统的构建了，所以我现在要分析的只是基本的功能实现
首先连接好数据库之后，那就是创建查询语句，这里用到的是statment这个关键词，下面是代码的基本实现

package dbtest;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class DbTest {
	public static void main(String[] args) {
		Employee employee1 =new Employee();
		employee1.setEmpno(555);
		employee1.setEname("hakly");
		employee1.setSal(5400);
		employee1.setHiredate(new Date());
		addEmployee(employee1);
		List<Employee>employees=getEmployees();
		for(Employee employee:employees){
			System.out.println(employee);
		}
		Employee employee =new Employee();
		employee.setEmpno(999);
		employee.setEname("jack");
		employee.setSal(5000);
		employee.setHiredate(new Date());
		addEmployee(employee);
	}
		public static List<Employee> getEmployees() {
		ResultSet rs=null;
		Connection conn=null;
		Statement stat=null;
		List<Employee> employees=new ArrayList<Employee>();
		try{
			Class.forName("com.mysql.jdbc.Driver");
		String url="jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8";
		String user="root";
		String password="root";
	    conn=	DriverManager.getConnection(url,user,password);
	    stat=conn.createStatement();
		String sql="select * from emp";
	     rs=stat.executeQuery(sql);
	     Employee employee=null;
		while(rs.next()){
			employee=new Employee();
			employee.setEmpno(rs.getInt("empno"));
			employee.setEname(rs.getString("ename"));
			employee.setSal(rs.getDouble("sal"));
		employee.setHiredate(rs.getDate("hiredate"));
		employees.add(employee);
		}
		}catch(Exception e ){
			e.printStackTrace();
		}finally{
			try {
				if(conn!=null){
				conn.close();
			}
				}catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return employees;
	}
	<!--more-->
		public static void addEmployee(Employee employee) {
			Connection conn = null;
			Statement stat = null;
			// 1.注册驱动程序
			try {
				Class.forName("com.mysql.jdbc.Driver");
				// 2.建立连接
				String url = "jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8";
				String user = "root";
				String password = "root";
				conn = DriverManager.getConnection(url, user, password);
				// 3.创建执行语句，发送sql命令
				stat = conn.createStatement();
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				String sql = "insert into emp(empno,ename,sal,hiredate) values(" + employee.getEmpno() + ",'"
						+ employee.getEname() + "'," + employee.getSal() + ",'" + sdf.format(employee.getHiredate()) + "')";
				// 4.处理执行结果
				int i = stat.executeUpdate(sql);
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				// 5.关闭资源
				try {
					if (conn != null) {
						conn.close();
					}
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		public static void updateEmployee(Employee employee) {
			Connection conn = null;
			Statement stat = null;
			// 1.注册驱动程序
			try {
				Class.forName("com.mysql.jdbc.Driver");
				// 2.建立连接
				String url = "jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8";
				String user = "root";
				String password = "root";
				conn = DriverManager.getConnection(url, user, password);
				// 3.创建执行语句，发送sql命令
				stat = conn.createStatement();
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				String sql = "update emp set ename='"+employee.getEname()+"empno"+employee.getEmpno()+"sal"+employee.getSal();
				// 4.处理执行结果
				int i = stat.executeUpdate(sql);
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally {
				// 5.关闭资源
				try {
					if (conn != null) {
						conn.close();
					}
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
}

这里的代码很繁琐，但是没办法，为了更清新一点的去了解，这个过程是必须的，然后接下来就是进行简单的优化，虽然代码还是差不多，但是感觉上会更加简洁了
，这里就要建立一个工具类了代码如下

package dbtest;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class JdbcUtil {
	static String url = "jdbc:mysql://localhost:3306/xxx?useUnicode=true&characterEncoding=utf-8";
	static String user = "root";
	static String password = "root";
	static{
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public static Connection getConnection() throws SQLException{
		String url = "jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8";
		String user = "root";
		String password = "root";
		return  DriverManager.getConnection(url, user, password);
	}
	public static void free(Connection conn){
		try {
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	}

在这里，把数据库连接和异常处理，等工作都及合成一个工具类，然后再主函数调用就可以了，这就是面向对象的一个体现，当然还是会分析下关于主类的代码，要不然就太过于空洞了，下面要分析的主类代码如下

package com.niit.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class EmployeeDao1 {
	public static void main(String[] args) throws ParseException {
		List<Employee> employees=getEmployees();
		for(Employee employee:employees){
			System.out.println(employee);
		}
		/*Employee employee = new Employee();
		employee.setEmpno(9999);
		employee.setEname("tom");
		employee.setSal(6000);
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
		employee.setHiredate(sdf.parse("2015-07-23"));
		//addEmployee(employee);
		//updateEmployee(employee);
		deleteEmployee(9999);*/
	}
	public static List<Employee> getEmployees() {
		Connection conn = null;
		Statement stat = null;
		ResultSet rs = null;
		List<Employee> employees = new ArrayList<Employee>();
		// 1.注册驱动程序
		try {
			//2.获取连接
			conn=JdbcUtil.getConnection();
			// 3.创建执行语句，发送sql命令
			stat = conn.createStatement();
			String sql = "select * from emp";
			// 4.处理执行结果
			rs = stat.executeQuery(sql);
			Employee employee = null;
			while (rs.next()) {
				employee = new Employee();
				employee.setEmpno(rs.getInt("empno"));
				employee.setEname(rs.getString("ename"));
				employee.setSal(rs.getDouble("sal"));
				employee.setHiredate(rs.getDate("hiredate"));
				employees.add(employee);
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			// 5.关闭资源
			JdbcUtil.free(conn);
		}
		return employees;
	}
	public static void addEmployee(Employee employee) {
		Connection conn = null;
		Statement stat = null;
		// 1.注册驱动程序
		try {
			//2.获取连接
			conn=JdbcUtil.getConnection();
			// 3.创建执行语句，发送sql命令
			stat = conn.createStatement();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			String sql = "insert into emp(empno,ename,sal,hiredate) values(" + employee.getEmpno() + ",'"
					+ employee.getEname() + "'," + employee.getSal() + ",'" + sdf.format(employee.getHiredate()) + "')";
			// 4.处理执行结果
			int i = stat.executeUpdate(sql);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			// 5.关闭资源
			JdbcUtil.free(conn);
		}
	}
	public static void updateEmployee(Employee employee) {
		Connection conn = null;
		Statement stat = null;
		// 1.注册驱动程序
		try {
			//2.获取连接
			conn=JdbcUtil.getConnection();
			// 3.创建执行语句，发送sql命令
			stat = conn.createStatement();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			String sql = "update emp set ename='" + employee.getEname() + "',sal=" + employee.getSal() + ",hiredate='"
					+ sdf.format(employee.getHiredate()) + "' where empno=" + employee.getEmpno();
			// 4.处理执行结果
			int i = stat.executeUpdate(sql);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			// 5.关闭资源
			JdbcUtil.free(conn);
		}
	}
	public static void deleteEmployee(int empno) {
		Connection conn = null;
		Statement stat = null;
		// 1.注册驱动程序
		try {
			//2.获取连接
			conn=JdbcUtil.getConnection();
			// 3.创建执行语句，发送sql命令
			stat = conn.createStatement();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			String sql = "delete from emp where empno="+empno;
			// 4.处理执行结果
			int i = stat.executeUpdate(sql);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			// 5.关闭资源
			JdbcUtil.free(conn);
		}
	}
}

这样看上去就比较清晰和明了，不用分割开来去看代码，只要调用到那个累才去照这个类的方法，这样就能够更加有利于检查和排错，维护的间接性的一个软件的奋斗的目标，虽然只是简单的优化，却能够减轻了我们写代码和维护的成本。

##总结
通过本次编码，对面向对象的编程的开发有更加清晰的了解，当然对重构和优化的重要性有更深的了解，在这个软件里我学会的不仅是代码的书写，还学会了代码的重构不仅需要不断的提炼，还需要对代码的细微的观察。

Sep 4

这路得一直走下去

第二阶段

人生三个阶段，学校期限，现在就在交点啦，我不确定的那些都是在这里相遇，虽然一直都有丝迷茫，我不知道但是我现在开始确定我已经处于社会形态这个阶段，我虽然不知道我未来的方向，但是我要开始适应和去想一下自己的未来，我要不要回去校招，虽然我们学校没有校招，但是我却是可以去其他的大学提交申请，虽然我知道我不够优秀，但是我确实想试试，但是接下来是要去找一个实习工作，然后把自己的债务给还上，无论是人情还是其他，我不想在消耗自己的善良去对待一些事吧，当我开始去面对这个社会的时候感觉自己还是挺幸运的，至少自己还有一些思考的空间，我不知道我会遇到什么磨砺，怎样的心情，但是我想象得到我不仅需要的是继续学习的心态，还有继续向前的勇气，思考的时候很容易代表我们之间的区别，不是为了阶级，而是我们在讨论的问题就不在一个线上啦，所以我很久以前就感受着不一样的待遇，然后渐渐的沉默，我不知道有时候也是对未来的一个预测吧，在这个节点，总是会有太多的路，我也想去继续看看，不仅仅为了看到更好的风景还想遇到不一样的人，我相信大学的友谊，老乡的情谊，继续保持下去，我虽然恨透了大学那些虚度的人，我有何不是在虚度中领悟，然后才有后来的先知先觉，这就我的一个看到的一个点吧，别人总是说一些最近的无聊的路程，所以我在看书，一些不想关的书，让我对自己的性格有进一步的了解，对社会的思考和对人生的思考不会只是无病呻吟，而是知道我们的时间片，你在这里要上演怎样的人生，这也许就是别人的一些想法对我的一个补充吧，零散的知乎和简书阅读让我能够了解更多的咨询，这也是一种锻炼自己的眼光的一个很好的寄托地吧，这不仅仅是让我认识更多的人和人生，这样需要的就不仅仅是我们未来性格的塑造

听君一席话

今天去找老乡，出去工作了两年的学长，在我印象中是在其他专业然后来到it行业来，他对我最深的一句话是说他刚出来的时候什么经验都没有，然后方向也不是太明确，然后就自己闯荡，现在不说太差，虽然不算是顶尖的，但是已经能够养活自己，并且能够让自己的生活有了一点改变，然后一直在充电，也许以后也会到我这个后端上来，最深的一句话就是要坚持的学习，和学长说了很多的技术，但是和我说的最多的还是希望我自己的去开发和跟进一些项目，我想这就是我以后要的方向，我妖之道我自己还在学习，所以我要懂得努力，不怕其他的，勇敢去闯，我知道最近有点自信啦，但是还是不够，因为还有很多其他的问题要学，前端的一些知识只是有点概念，所以我要继续去熟悉，然后多一点去推介文章和阅读一些其他人的文章，学习格式和其他的一些东西，不仅仅是对我的教导，还有对我的一些建议，都很受用，有一个师兄，确实能够帮助自己很多，我不想继续呆在学校，所以我需要好好的去规划，自己的接下来的路，这不仅仅是对自己的考验，还有就是让自己积累一些经验，我不知道我以后的工作怎么样，但是我知道我要调整自己的心态，勇敢的甘于平凡，勇于去承担，勇于去抗压，这样才能够学到更好的技术和人脉

总结

走动不仅是人脉，还有是对未来的向往，我要勇于捉住机会，我需要爬更高的山河看更美的风景，写得有点乱，不过时间就这样。

Sep 2

网上小卖部的设计和实现

开始去做的时候才知道这才是努力

软件背景

在当今时代什么事情都可能发生，在我十几年的生涯中，小卖部的凌乱给我留下了很大的印象，分类不够合理，账单比较随意，进出帐单没有章节，所以开了很多年都是很稳定，没有挣到什么钱，但是却让我的心算有了一点起色，不过在这里，我希望开发一个简单的易用的网络在线小卖部，也许项目不是很大，但是对于我这个新手来说估计也足够啦，所以想了想，还是把它写下来，仅当是对这个小项目的一个回顾

软件前景和规划

作为一个严谨一点的我，还是决定写下这个项目的前景，现在淘宝的小店开启新农村模式，现在城市的市场已经趋向于饱和，急需开拓国际市场和农村市场，这是这个软件的应运而生，实现了简单的前后台分离，界面简单，应用在商品在小于100以内的小店使用，规划是实现商品的添加和删除，实现进出库的汇总和营收额的结算简单功能，现在要使用到的技术栈使用了简单的servlet和c3p0的数据库导入，使用jsp作为前端的现实，虽然简陋，不过还是有生存的空间

使用周期大概五年

咋这段时间争取做到系统的更新和换代，可是现在要出去工作啦，估计时间上会有欠缺的，不过我相信既然想到开发就有存在的道理
好啦，废话少说，开始我的网上小卖部的开发
首先开发jopo层和数据库的简单应用，开始享用hibernate后来想了想还是用原始的c3p0连接，虽然繁琐，但是没有那么重，而且处理的数据相对极少，从而确定了商品和用户还有就是订单和分类四个对象去构建这个软件，然后接下来是先连接数据库

import entity.User;
public interface UserDao {
    void add(User user);
    User find(String id);
    User find(String username, String password);
public class UserDaoImpl implements UserDao{
    @Override
    public void add(User user) {
        // TODO Auto-generated method stub
        try{
            QueryRunner runner=new QueryRunner(JdbcUtils.getDataSource());
           String sql="insert into user(id,username,password,phone,cellphone,address,email)values(?,?,?,?,?,?,?)";
           Object params[]={user.getId(),user.getUsername(),user.getPassword(),user.getPhone(),user.getCellphone(),user.getAddress(),user.getEmail()};
           runner.update(sql,params);
        }catch(Exception e){
            throw new RuntimeException(e);
        }
    }
}

使用了最原始的连接方式，这样虽然每次要查找或者其他都要书写这么一段代码，但是这样却是能够更进一步了解更多实在的东西，就像今天的错误一样，看到了最基本的查询语句才能够快速的纠正错误。这样是实现了基本可i型和表的关系，这样我们只要在网络上接受数据类型的信息就能够存储到数据库中
接下来要写的当然就是服务即就是书写这个软件的逻辑，这样要考虑的地方就有很多，比如说分页问题，商品的基本操作和现实，这就会用到一些其他技术，比如反射，不过这里只是为了获取class，倒没有太过于深入的去写这个，毕竟我还有很多的地方没弄明白，还是慎用为好，下面使用一段代码来说明下吧，感觉都没有真正的把自己的表达说得更加仔细啦

public void createOrder(Cart cart,User user){
    if(cart==null){
        throw new RuntimeException("对不起。你没有购买任何商品");
    }
    Order order =new Order();
    order.setId(WebUtils.makeID());
    order.setOrdertime(new Date());
    order.setPrice(cart.getPrice());
    order.setState(false);
    order.setUser(user);
    for(Map.Entry<String, CartItem>me:cart.getMap().entrySet()){
        CartItem citem=me.getValue();
        OrderItem oitem=new OrderItem();
        oitem.setGoods(citem.getGoods());
        oitem.setPrice(citem.getPrice());
        oitem.setId(WebUtils.makeID());
        oitem.setQuantity(citem.getQuantity());
        order.getOrderitems().add(oitem);
    }
    orderDao.add(order);
}
public List<Order> listOrder(String state) {
    return orderDao.getAll(Boolean.parseBoolean(state));    
}

总结

在开发这个过程中，遇到很多坑，不过最后虽然还不怎么让我满意，但是我却对各个流程有一个了解吧，其他的以后再说吧。

Aug 30

实训面试总结

面试即是为了让你选择公司，也是为了公司选择你

关于面试前的选择

在这次的模拟面试中，很多人都暴露了不少的问题，首先面试的时候应该保持一个平和的心态，要不然就会紧张，在交到自己的时候，先试着让自己平静下来，这样不会忘记所有，第一关的基本都是hr面试，所以你更加突出的是你个人的性格和对这个行业的认识，当然还可以让面试官认识你其他方面的表现，比如说阅历还有经验，当然现在我们没有多少走出去的经验，所以我们更应该注重表达的是你自身的优点和已经成功的事情，让面试官有一个整体的有印象，当然面试时候的礼仪也是要注意的，当然最主要的还是对自己的肯定，当我要走上去的时候，首先我心中有一个底稿子，然后才会在介绍自己的时候没有乱了方寸，很多的程序猿的表达能力都不是太过关，我也一样，，但是我需要锻炼的是自己的表述能力，所以我上去的时候首先深呼吸了一下，然后环顾了一下环境，然后才开始介绍自己的背景，然后介绍自己的学习历程，项目思考和实现，在这里我选择了一个相关的项目，然后大概描述了一些技术栈和所需要的环境，然后简单介绍了我在实现的时候遇到的问题，测试和架构的时候遇到的问题，我想我最有的特色就是懂得不会就学，不屈服在一个技术和领域，我在深入的学习和沟通自己的知识体系，然后在默念自己的目标和信念，我相信，有志者事竟成，无论遇到什么，这都是我的磨砺，我会选择我最好的姿势去面对。

###关于面试时的想法，
在介绍我自己的时候突然忘记了一个技术栈，然后我马上跳过，宁可不说，也不能说错一些自己不熟悉的领域，然后接下来的关于性格和优势的介绍中，我都在务实的回答和阻止自己的语言，我在介绍中提到了团结合作和敢于承担责任，并且在实施过程中懂得变通，这就是我最大的优势吧，不是，我最大的有点，我觉得是我的文字的亲和力，所以我在生活中都在锻炼我的表述，我希望我能够用文字来表达我所学到的，和我所想到的，所以我的思想总是没有边界，这也是创造力的一个体现，但是我还是缺乏太强的执行力，所以我需要的不仅是锻炼我的技能，还有我的表达能力，我先要懂得做人，还有度人，所以交流是我生活的一部分，我不仅仅是为了编程，最主要还是把生活中遇到的问题用软件来实现，所以我在哪里的去构造自己的世界，不仅仅是为了未来，还有懒的付出，我想到的最好的未来就是这样吧。在提问中老师问到了最可能问道的问题，我觉得老师的问题很让人满意，但是我最后还是坚持我自己的想法，就是要提高自己的效率，现在学习都没什么效率，因为我只是为了学习而学习，而不是为了解决生活中的困难去学校，所以我很羡慕朋也的设计，自己解决了自己想要的，想看自己的动漫，然后自己建立自己的软件，然后分享和交流自己的建站的经验，这也是我很好的去学校的方式吧，你自己付出才能够让别人去志愿你，我想这就是软件开发的一大优势吧，懂得分享，当然估计也有人问到如何到这条路上，为何喜欢挑战，这些都是面试需要思考的问题，虽然不一定是正确的，但是你要懂得取舍，我知道我自己的选择，无愧自己的选择

关于如何做好一个规范的开发者

我想以后很多人都希望转向管理，但是我没这么想，因为我们需要的不仅仅是管理，还有资深的开发者，所以我选择了另一个方向，架构师，这是在高屋建瓴，这也是一个友坂头的方向，至少没有脱离自己的想法，继续去开创自己的想法，虽然说很难，但是我觉得年轻就需要去闯荡，当你有勇气继续前进，技术就是你最好的礼物。无论在那个面试，我希望做到自我的自信，因为我相信我自己能够胜任自己的选择，我希望我有自己的选择和自己未来。

###总结
通过这个面试介绍，大概了解了不少关于面试的未来的方向，所以我会这个方向及训练，当然更重要的是深入的去开发，和实现业务逻辑，让自己更充实自己，加油，我自己，我未来。

Aug 22

向远方去

旅途见闻

每一次坐车都喜欢带一本书，很多人说这是为了装文艺，但是我心中有自己的衡量，我一直都不是一个文艺的人，我只是我，带一本书，也许在车上不看，但是却能够给予我一种心安，对待读书和生活的一种思考，也许是一种书香的诱惑吧，但是这也仅仅是一站，对接未来，衔接梦想的一点回忆吧，这样的旅行总会遇到改遇到的人和事，不仅仅对自己，还有以身作则的我，是否也是旅途的一道风景线，我知道我没有太大的人格魅力，但是我确信我还有自己的魄力，对待每件事都要有自己的 b

Aug 19

回家那些琐事

很多事情都需要自己的见闻去支撑你的理论

回家只是为了心慰

家永远是我们需要藏在心里的一个地方，即使你的学识沾满了异乡的味道，但是家还是会遗留一片净土让家这个词来填满，无论是“月是故乡明”，还是“近乡情更怯”都在反应着一个人最初的心理反应，家乡永远是我们无法割舍的地方，在他乡的音调还在回旋，古今那么多的歌颂者都是集思乡之大成者，都在有意无意的去追寻一个心灵的港湾，我也不例外，火车的延伸支边就是我的家乡，三面环山，还是河流的北边那些房子的倒影就是我故乡的缩影，没有鲁迅先生那故乡水乡的宁静，但是却又独特山村的那份宁谧和娴静，不知道从何时起，在学妹的声讨中我也会想到我的家，温暖的家。

家里的窝，我滴最好的栖息地

简陋的房子，堆满杂物的房间，这就是我最初的房子啦，这里无需太多的感情寄托，但是确实我小时和童年最好的回忆，没有很多的杂乱无章，有点是小学到初中的一些书籍，读过的一些书还有写过的小说，断章取义的拿来，却怎么也想不起那时候我的状态和心境，写出了那么悲伤的文字，文字虽然是记载自己的经历和表达方式的，但却不是全是一些矫情的话语，那样就失去了很多味道了，这是写实的一个禁忌，虽然说写出了困境，但是却暴露了一个人脆弱的内心世界，假如没办法克服，这种情感就没有用武之地，所以写一件事，要写出这件事的意义，写村中对大学的误解，要突出信息闭塞和教育程度的局部性，要懂得从一件事去概括一个问题的答案，不要因为其他的原因去放弃观察，我知道这有点微言微听，但是这确实代表着农村对新信息的接受能力和推广能力的补足，快递的缺乏和网路的布设都是现在急需提高的一项民生工程，降低农村的开销也是重重之重，教育方面的问题我认为是特别突出，教育的不均衡绝对是一个要解决的问题，虽然九年教育的普及，但是我没有见到真正在九年里受益的人，鄙视和对大学生的要求也在提高，让我感觉到更大的压力，这也许是很多人的共同的心病吧，教育总是在剥夺着一些人的权利，我不知道这些人问题是否践约，但是我知道我有义务去关注，去了解这些东西，要懂得别人的困苦才知道自己的幸运，但是我不想只是幸灾乐祸者，而是一个见证者，写的不仅是自己的所见所闻还有是对生活的一种检阅，我不想真正去该变什么，因为我要的只是自己的平凡，曾经想过用一个技术去改变自己的家乡，现在觉得那么的不现实，不过我还是想向这个目标去前进，我想即使最后坯体鳞伤，也会觉得自己为自己的信念去奋斗，而不是一个无根的人，随波逐流，我要做的只是爬上岸，其他的看自己找到什么样的财富去改变。

村野的话语，小智慧

很多人村野的人没有到过太多的地方，却是知晓很多别人不知道的技巧和故事，除了赌博的一些讨论，更多却是在分享着各自的经历和阅历，妇女们的一些关于育儿的教育我却不是很清楚，但是老人和年轻一代的交流却更多的是交流心得，比如做装修的技巧和人物性格的分析，如何去交际和如何去关注共同的东西，当然我跟感兴趣的是闯荡人的心路历程，虽然没有真正去体会，但是我确实知道生活不容易，很多人都是进工厂很麻木的用时间去换取生活的支撑，家总是需要一个人去支撑的，即使在困难，也会熬过去，所以很多人到了而立之年就会回来养儿育女，不知道这是不是一个人的命运轨迹，但是我的心也是这样吗，那么安稳和平静，我甘于平凡，但不想墨玉成规的生活，我希望每天都在改变，不要求轰轰烈烈，但是并不像做一个麻木的人，只有时间的积累去换取一分薪水，这样的生活也许就是归宿，我虽然不想和天正，但是这样的未来我还是想打破，至少在困苦，我也要活出自己的样。大城市的生活我不习惯也罢，我需要的是一鼓作气把。也许平平凡凡才是最大的幸福吧。

为了什么而坚持

为了最后坚守的信念吧。我都需要在自己的领域闯荡出自己的一片天地，我知道这个很难，但是当你不断学习的过程就是成长的过程，加油，我就是我，喜爱编程和文学的我。

Aug 10

如何寻找自我的价值和方向

锲子

在回家之后的这段时间里，看了乐嘉的《本色》，一个关于色彩去解读不同人生的书籍，看了梁文道的《关键字》，看到了关键字在不同时期的改变，逐步被社会的浪潮冲刷，还原一个真实的社会形态，然后看了熊老师写得《重新发现社会》，探讨了关于社会性质和国家性质的一种说法，当然也有关于事实的一种观望态度，接着认真的去读了一遍《沉思录》，反思自己的生活的点滴去对照不同的归宿，这是我最喜欢的一本关于总结过去的书籍，我发现我本人总是在遗忘着一些事情，所以用笔记的方式去回忆，整理这些读书笔记，也许是人生的一些痕迹吧，就当是作为休闲时间对世界的一次接触，然后归于平淡。很多人现在的书籍并不一定是文采斐然的人写，只要你能够写出自己的感悟，我觉得这就是最好的表达方式，很多人都在界定着艺术的范畴，我觉得只要是用一种表现形式表达出社会，个人的想法和特点的，并给予一些特殊含义的所有事物，都觉得应该是艺术的组成部分，不分种族和时间和领域的限制，所以我要说的就是这些无关紧要的一些碎笔，也许是我的人生观和价值观，世界观的一个体现吧。关于读书，关于编程，关于生活，都在这里的一片小的天地，我希望能够总结过去，展望未来，把握当下的时间和安排，我的微笑和努力尽在无言中。
读书的起点就是开始思考的开始
当你开始读书的时候，你就应该开始去思考，为何而读这本书，为何读这本书就一定能够受益，以为中国人喜欢“一分收获一分耕耘”，所以总带着结果性的去阅读一本书，我觉得最后你除了记住时间地点，主角，我想你不会记住一丝其他的养分，这样和阅读一个简报有什么区别，今天站在这里，这里就是我书籍的家园，所认真对待每一本书，每一本书都代表着一种价值取向，你个人意志的体现，书中作者的那厮残留的影像，还是别人的笔记反应者一个强者的路，我觉得却不适合自我创新的决心，我觉得这就是读书的开端吧，我站在大路上也许就有人在个读书阅读，慢慢的去感化着，所以我喜欢一些书，关于批判，关于选位，最终服务的对象还是人们，所以这就是我不太愿意提到的一个小小的问题，所以现在开始读书，然后慢慢的磨灭那些东西，我想这就是看到的吗。