我是如何学习Hibernate的(三)

发表于 2016-05-02 |

前述

在学习Struts2、Hibernate、Sping、String MVC、Mybatis等几大框架的时候，并没有使用版本控制软件。我知道版本控制的重要性，所以我在其间学习了Git，我会在学完了Git之后写一篇我如何学习Git的文章。

关联关系

一对一关系映射即为关系双方都含有对方的一个引用，比如人和身份证，学生和学号都是一对一关系映射。(了解)

主表的主键，与从表的外键，形成主外键关系。
比如：课程编号(课程表中的主键) — 课程编号(学生表中的外键)

主表的主键，与从表的主键，形成主外键关系。(从表的主键是主表的外键)

一对多

一对多关系映射中，一方含有多方的一个集合引用，而多方含有一方的单个引用。
以Customer和Order为例子演示一对多的实现：

Customer类

package com.hibernate3;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.Id;

public class Customer {

	private Integer uid;
	private String name;
	private Set<Order> orderSet = new HashSet<Order>();
}

Customer.hbm.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    
    <hibernate-mapping>
    <class name="com.hibernate3.Customer" table="customer">
    <id name="uid" column="id" >
      <generator class="native" />
    </id>
    <set name="orderSet" inverse="true">//inverse=true，表示控制反转，通常由一方交出控制权给多方
      <key column="uid" />
      <one-to-many class="com.hibernate3.Order"/> //这里写对应的many方的class全名
    </set>
    <property name="name" column="name" />
    </class>
    </hibernate-mapping>

Order类

package com.hibernate3;

import java.util.HashSet;
import java.util.Set;

public class Order {

	private Integer oid;
	private Integer price;
	private Customer customer;
}
``` 

## Order.hbm.xml配置文件
``` bash
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    
    <hibernate-mapping> 
    <class name="com.hibernate3.Order" table="t_order">
    <id name="oid" column="id" >
          <generator class="native" />
    </id>
    <many-to-one name="customer" class="com.hibernate3.Customer" column="uid">
    </many-to-one>
      <property name="price" />
    </class>
    </hibernate-mapping>

Hibernate的工具类

package com.hibernate3;

import javax.imageio.spi.ServiceRegistry;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {

	private static SessionFactory sessionFactory;
	private static Session session;
	
	static{
		Configuration config = new Configuration().configure();
		sessionFactory = config.buildSessionFactory();
		session=sessionFactory.openSession();
	}

	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}


	public static Session getSession() {
		return session;
	}

    public static void closeSession(Session session){
    	if(session!=null){
    		session.close();
    		session=null;
    	}
    }
}

OneToManyDao

package com.hibernate3;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

public class OneToManyDao {
	
	@Test
	public  void add(){
		Session session =HibernateUtils.getSession();
		Transaction tc = session.beginTransaction();
		
		Customer c= new Customer();
		c.setName("李明辉");
		Order o = new Order();
		o.setPrice(3);
		c.getOrderSet().add(o);
		o.setCustomer(c);
		
		
		session.save(c);
		session.save(o);//可交换顺序看看哪种方式是最优方式
		
		tc.commit();
		HibernateUtils.closeSession(session);
		
	}
}

多对多

多个学生可以学习不同课程

/** 学生实体类 */

public class Student {

	private Long id;                //对象标识符(OID)
	private String name;            //姓名
	private String grade;           //所在班级
	private Set<Course> courses;    //所有所选课程的集合
}

<hibernate-mapping>

  <!-- 映射持久化类 -->

<class name="com.domain.Student" table="student">

<!-- 映射对象标识符 -->

<id name="id" column="id" type="long">

<generator class="native" />

</id>

<!-- 映射普通属性 -->

<property name="name" />

<property name="grade" />

<!-- 映射集合属性,指定连接表 -->

<set name="courses" table="student_course">

<!-- 用key元素指定本持久类在连接表中的外键字段名 -->

<key column="student_id" />

<!-- 映射多对多关联类 -->

      <many-to-many column="course_id" 

       class="com.omain.Course" />

</set>

</class>

</hibernate-mapping>

/** 课程实体类 */

public class Course {

	private Long id;                //对象标识符(OID)
	private String name;            //课程名
	private Double creditHours;     //课时数
	private Set<Student> students;  //选择了这门课程的学生的集合
}

Course.hbm.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.domain.Course" table="course">

<!-- 映射对象标识符 -->

<id name="id" column="id" type="long">

<generator class="native" />

</id>

<!-- 映射普通属性 -->

<property name="name" />

<property name="creditHours" column="credit_hours" />

<!-- 映射集合属性,指定连接表 -->
<!-- inverse="true"表示交出控制权,在多对多关系映射中，必须有一方要设置为true -->
<set name="students" table="student_course" inverse="true"> 

<!-- 用key元素指定本持久类在连接表中的外键字段名 -->

<key column="course_id" />

<!-- 映射多对多关联类 -->

<many-to-many column="student_id" class="com.domain.Student" />

</set>

</class>

</hibernate-mapping>

我是如何学习Hibernate的(二)

发表于 2016-05-01 |

前述

在前一篇博客中，我记录了Hibernate的环境的搭建，并且熟悉了一次Hibernate执行的过程。我在后面的博客中，会记录更多关于hibernate中的知识点。总共会有以下所有内容:

整合log4j
配置文件
API
Hibernate CRUD操作
PO对象的操作
一级缓存
二级缓存
关联关系
抓取策略
HQL
事务隔离

一.整合log4j

log4j是Apache组织的一个开源项目，用于将日志信息输送到控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器。我们可以控制每一条日志的输出格式，还可以通过定义日志信息的级别，而这一切操作，都可以通过配置文件来完成。

引入jar包：到log4j官网就可以下载到。

配置文件log4j.properties

#The five logging levels used by Log are (in order):  
#   
#1. DEBUG (the least serious)  
#2. INFO  
#3. WARN  
#4. ERROR  
#5. FATAL (the most serious)  
   
#Set root logger level to INFO and append to stdout  
log4j.rootLogger=INFO,stdout,file
#设置log的级别为INFO意味着INFO级别以下如DEBUG的信息不会输出
#其中，Log4j提供的appender有以下几种：
#org.apache.log4j.ConsoleAppender（控制台），
#org.apache.log4j.FileAppender（文件），
#org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
#org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
#org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

#其中，Log4j提供的layout有以几种：
#org.apache.log4j.HTMLLayout（以HTML表格形式布局），
#org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
#org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
#org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

#Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下： 
#%m 输出代码中指定的消息
#%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
#%r 输出自应用启动到输出该log信息耗费的毫秒数
#%c 输出所属的类目，通常就是所在类的全名
#%t 输出产生该日志事件的线程名
#%n 输出一个回车换行符，Windows平台为“rn”，Unix平台为“n”
#%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2016年5月1日 22：10：28，921
#%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

#stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout    
log4j.appender.stdout.layout.ConversionPattern=[%p]%-d{yyyy-MM-dd HH\:mm\:ss}[%c\:%L] %m%n  

#file
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender  
log4j.appender.file.File=/output.log
log4j.appender.file.DatePattern='.'yyyy-MM-dd  
log4j.appender.file.layout=org.apache.log4j.PatternLayout  
log4j.appender.file.layout.ConversionPattern=[%p]%-d{yyyy-MM-dd HH\:mm\:ss}[%c\:%L] %m%n
#log4j.appender.file=org.apache.log4j.DailyRollingFileAppender  
#log4j.appender.file.File=/output.html
#log4j.appender.file.DatePattern='.'yyyy-MM-dd  
#log4j.appender.file.layout=org.apache.log4j.HTMLLayout 
#log4j.appender.file.layout.ConversionPattern=[%p]%-d{yyyy-MM-dd HH\:mm\:ss}[%c\:%L] %m%n

#Print only messages of level ERROR or above in the package noModule.  
log4j.logger.noModule=INFO

二.核心配置文件hibernate.cfg.xml

<hibernate-configuration>
<session-factory>
<!-- 配置Hibernate基本信息 -->

   <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
   <property name="connection.url">jdbc:mysql://localhost/hibernate001</property>
   <property name="connection.username">root</property>
   <property name="connection.password">jessyon6233834</property>

<!-- 配置Hibernate方言 -->
<property name="hibernate.dialect ">
	org.hibernate.dialect.MySQLDialect
</property>
   <property name="hibernate.hbm2ddl.auto">update</property>
<!-- 可选属性 -->
<property name="hibernate.show_sql">true</property>

<!-- 格式化sql -->
<property name="hibernate.format_sql">true</property>

<!-- 通知Hibernate加载哪些配置-->
<mapping resource="com/hibernate3/Customer.hbm.xml" /> 
<mapping resource="com/hibernate3/Order.hbm.xml"/>

</session-factory>
</hibernate-configuration>

Hibernate映射配置文件

<hibernate-mapping>
<class name="com.hibernate3.Customer" table="customer"> 
<id name="id" column="id" >
      <generator class="native" />
  </id>
   
<property name="name" column="name" type="string" length="20"/>
<property name="age" column="age"></property>
</class>
</hibernate-mapping>

三.常用API

读取并解析配置文件 Configuration conf = new Configuration().configure();
读取并解析映射信息，创建SessionFactory SessionFactory sf = conf.buildSessionFactory();
打开Session Session session = sf.openSession();
开始一个事务（增删改操作必须，查询操作可选） Transaction tx = session.beginTransaction();
数据库操作 session.save(user);//或其它操作
提交事务(回滚事务) tx.commit();(tx.rollback();)
关闭session session.close();

Configuration是默认加载hibernate.cfg.xml这个文件的，但也提供了重载的方法
public Configuration configure(String resource)
public Configuration configure(URL url)
public Configuration configure(File configFile)
SessionFactiory：Configuration的实例会根据当前的配置信息，构造SessionFactory实例。SessionFactory是线程安全的，一般情况下一个应用中一个数据库共享一个SessionFactory实例。
Hibernate的SessionFactory接口提供Session类的实例，Session类用于完成对数据库的操作。由于SessionFactory实例是线程安全的（而Session实例不是线程安全的），所以每个操作都可以共用同一个SessionFactory来获取Session。
从XML文件读取配置信息构建SessionFactory
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
Session：一般的持久化方法(CRUD)都是通过Session来调用的,Session是非线程安全的。
Session的创建与关闭：Session是一个轻量级对象，通常将每个Session实例和一个数据库事务绑定，也就是每执行一个数据库事务，都应该先创建一个新的Session实例，在使用Session后，还需要关闭Session。
Session的创建
创建SessionFactory后，就可以通过SessionFactory创建Session实例，通过SessionFactory创建Session实例的代码如下。
Session session=sessionFactory.openSession();
创建Session后，就可以通过创建的Session进行持久化操作了。
Session的关闭
在创建Session实例后，不论是否执行事务，最后都需要关闭Session实例，释放Session实例占用的资源。
关闭Session实例的代码如下：
session.close();
下面来看一下：getCurrentSession 与 openSession() 的区别
1.getCurrentSession创建的session会和绑定到当前线程,而openSession不会。
2 getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭
3.getCurrentSession () 使用当前的session，openSession() 重新建立一个新的session
这里getCurrentSession本地事务(本地事务:jdbc)时要在配置文件里进行如下设置
如果使用的是本地事务（jdbc事务）

1	<property name="hibernate.current_session_context_class">thread</property>

如果使用的是全局事务（jta事务）

1	<property name="hibernate.current_session_context_class">jta</property>

openSession() 与 getCurrentSession() 有何不同和关联呢？
在SessionFactory启动的时候Hibernate会根据配置创建相应的CurrentSessionContext,在getCurrentSession()被调用的时候，实际被执行的方法是CurrentSessionContext.currentSession()。在currentSession()执行时，如果当前Session为空,currentSession会调用SessionFactory的openSession所以getCurrentSession()对于avaEE来说是更好的获取Session的方法。

Transaction: hibernate把AutoCommit关掉了，所以如果想要进行数据操作，又不开启事务的话，数据库就不会有任何改变。

我是如何学习Hibernate的(一)

发表于 2016-04-30 |

前述

在搭建这个博客之前，我一直使用Word，OneNote等工具来记录我的学习过程。我会经常上iteye，CSDN查阅我想要的知识点。如果碰到很复杂的问题，或者说很少遇到的问题，那么我会在Stack Overflow查找相关问题，我的网站取名为OneStack，也有一半是为此。另一半大概就是我的理想是成为全栈工程师吧。

Hibernate入门

简介

ORM框架:Object Relational Mapping(对象关系映射)是关系型数据库和面向对象型数据库过渡时期的一个框架。Object指的是JavaBean，Relational指的是关系，二维表，数据库中的表。Mapping对象中的属性，与表的字段，存在的对应关系。
Hibernate:在基于MVC设计模式的JAVA WEB应用中，Hibernate可以作为模型层/数据访问层。它通过配置文件(hibernate.cfg.xml)和映射文件(*.hbm.xml)把JAVA对象或PO(Persistent Object,持久化对象)映射到数据库中的数据库，然后通过操作PO，对数据表中的数据进行增，删，改，查等操作。
PO:Persistent Object 持久化对象。
JPA Java Persistence API (规范):JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。
优点:
hibernate对JDBC访问数据库的代码进行了封装，大大简化了数据访问层繁琐的重复性代码。
hibernate是一个持久化框架，是一个优秀的ORM实现，很大程度上简化了dao层的工作。
hibernate使用了Java的反射机制。
hibernate性能非常好，因为它是一个轻量级框架。映射的灵活性很出色，它支持关系性数据库，从一对一到多对多的各种复杂关系。
hibernate核心组件
Configuration类：用来读取Hibernate配置文件，并生成SessionFactory对象。
SessionFactory接口：实例化Session工厂。
Session接口：用来操作PO，有get(),load(),save(),update(),delete()等方法来对PO进行加载，保存，更新，删除等操作。它是Hibernate的核心接口。
Query接口：用来对PO进行查询操作。,它可以从Session的createQuery()方法生成。
Transcation接口: 用来管理数据的的事务的接口，调用begin()方法可以开启事务，调用end()方法结束事务。在开启事务期间，可以commit()把PO保存到数据库中，或者rollback()回滚当前事务的操作。
Persistent Object
持久化对象可以是普通的JavaBean，唯一的区别就是PO与且仅与一个Session想关联。JavaBean在Hibenate中存在三种状态(理解，不背):
临时状态(transient):当new出来的JavaBean，在内存中孤立存在，不与数据库中的数据有任何联系时(没ID)，称这个JavaBean为临时对象。
持久化状态(Persistent Object):当一个JavaBean与Session相关联时，JavaBean就从transient转变为perisistent。
脱管态状态(detached):当与JavaBean相关联的Session关闭时，JavaBean也就变成了detached状态，可以被应用程序的任何层自由使用，例如可以作与表示层打交道的数据对象(Data Tranfer Object)。
Hibernate的运行过程
应用程序首先调用Configration类，该类读取Hibernate的配置文件及映射文件中的信息，并用这些信息生成一个SessionFactory对象。
SessionFactory对象生成一个Session，用Session联系一个PO，并让Session产生一个Transaction,通过session的get(),load(),save(),update(),delete()等方法，对PO进行操作。当session执行commit()时，将事务里的操作提交到数据库。如果执行rollback()，那就不提交。在查询情况下，可通过Session.createQuery()生成一个Query对象，然后Query对象可以调用list()执行查询操作。
Hibernate的运行过程如下图:

一次完整的Hibernate编程

数据库

create table T_register
(
id int primary key,
userName varchar(30),
userPwd varchar(30),
sex varchar(10),
age int
)

视图层: 注册页面register.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="servlet/RegisterServlet" method="POST">
    用户名：<input type="text" name="userName" /><BR>
    密  码：<input type="text" name="userPwd" /><BR>
    性  别：<input type="text" name="sex" /><BR>
    年  龄：<input type="text" name="age" /><BR>
    <input type="submit" value="save" />
</form>
</body>
</html>

设计持久化类TRegister.java

package hibernate.PO;
/**
 * 持久化类
 *以后的POJO，除了特别说明，均省略get、set方法和不重要的包名
 */

public class TRegister  implements java.io.Serializable {

     private Integer id;
     private String userName;
     private String userPwd;
     private String sex;
     private Integer age;



}

设计Hibernate配置文件hibernate.cfg.xml

	<hibernate-configuration>
    <session-factory>
	<!-- 配置Hibernate基本信息 -->

    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <property name="connection.url">jdbc:mysql://localhost/hibernate001</property>
    <property name="connection.username">root</property>
    <property name="connection.password">12345</property>

	<!-- 配置Hibernate方言 -->
			
	<property name="hibernate.dialect ">
		org.hibernate.dialect.MySQLDialect
	</property>

	<!-- 可选属性 -->
	<property name="hibernate.show_sql">true</property>

	<!-- 格式化sql -->
	<property name="hibernate.format_sql">true</property>

	<!-- 通知Hibernate加载哪些配置-->
	<mapping resource="hibernate/PO/TRegister.hbm.xml" />

	</session-factory>
	</hibernate-configuration>
```	
## 设计映射文件TRegister.hbm.xml
	<hibernate-mapping>
		<class name="hibernate.PO.TRegister" table="t_register">
			<id name="id" type="java.lang.Integer">
				<column name="id" />
				<generator class="increment" />
			</id>
			<property name="userName" type="java.lang.String">
				<column name="userName" length="30" />
			</property>
			<property name="userPwd" type="java.lang.String">
				<column name="userPwd" length="30" />
			</property>
			<property name="sex" type="java.lang.String">
				<column name="sex" length="10" />
			</property>
			<property name="age" type="java.lang.Integer">
				<column name="age" />
			</property>
		</class>
	</hibernate-mapping>

## 设计hibernate基础类HibernateUtil.java
``` bash
	package hibernate;

	public class HibernateUtil {
		
		private static final SessionFactory sessionFactory;
		
		static
		{
			try
			{
				Configuration config = new Configuration().configure("/hibernate/hibernate.cfg.xml");
				sessionFactory = config.buildSessionFactory();
			}
			catch(Throwable e)
			{
				throw new ExceptionInInitializerError(e);
			}
		}
		
		public static final ThreadLocal session = new ThreadLocal();
		
		public static Session currentSession() throws HibernateException
		{
			Session s = (Session)session.get();
			if(s == null || !s.isOpen())
			{
				s = sessionFactory.openSession();
				session.set(s);
			}
			return s;
		}
		
		public static void closeSession() throws HibernateException
		{
			Session s = (Session)session.get();
			session.set(null);
			if(s != null)
				s.close();
		}

	}

设计控制类

package hibernate.servlet;

public class RegisterServlet extends HttpServlet {

	private static final String CONTENT_TYPE = "text/html;charset=UTF-8";
	public void init() throws ServletException {

	}
	public void destroy() {
		super.destroy(); 
	}

	
	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		response.setContentType(CONTENT_TYPE);
		request.setCharacterEncoding("UTF-8");
		
		PrintWriter out = response.getWriter();
		
		String userName = request.getParameter("userName");
		String userPwd = request.getParameter("userPwd");
		String sex = request.getParameter("sex");
		int age = Integer.parseInt(request.getParameter("age"));
		
		TRegister rg = new TRegister();
		rg.setAge(age);
		rg.setSex(sex);
		rg.setUserName(userName);
		rg.setUserPwd(userPwd);
		
		Session session = HibernateUtil.currentSession();//生成Session实例
		Transaction tx = session.beginTransaction();
		
		try
		{
			session.save(rg);    //保存持久类对象
			tx.commit();        //提交到数据库
			session.close();
			response.sendRedirect("registerOK.jsp");
		}
		catch(HibernateException e)
		{
			e.printStackTrace();
			tx.rollback();
		}
		
	}
}

我是如何使用lantern科学上网的

发表于 2016-04-29 |

简介

lantern

lantern(蓝灯)是一个科学上网的工具,安装了lantern之后，Chrome可以直接科学上网
这是我分享的地址链接：http://pan.baidu.com/s/1qXTuI4k 密码：vk3a
下载后，直接安装之后就可以使用了。
lantern有自己的官方网站，但是并不能直接访问。如果这个版本使用不了，那么可以到百度贴吧找到最新版下载。

我是如何使用hexo搭建这个blog的

发表于 2016-04-29 |

简介部分

工具简介

Git是一款基于命令行的版本控制软件。
GitHub是Linus Torvalds为了在Linux操作系统上帮助程序员控制软件版本的一个开源网站。我们需要GitHub来托管我们的代码、资源等静态资源。
GitHub Pages是GitHub提供的300MB免费Websites空间。
Node.js是一个基于谷歌V8引擎的JavaScript运行环境(runtime),用于方便地搭建速度快、易扩展的网络应用。
hexo是一款基于Node.js的静态博客框架。
搭建环境
1.到Git下载安装，一路下一步，直到完成。
2.安装Node.js,一路下一步，直到完成。安装完成之后，需要配置环境: 我的电脑–属性–高级系统设置–环境变量–Path下添加 ;C:\Program Files\nodejs\
3.安装hexo:右键桌面，点击Git Base Here并执行一下指令:
1
$ npm install-g hexo

4.初始化hexo:在本地硬盘新建一个文件夹(名字自己取),右键点击空白处，点击 Git Base Here

1	$ hexo init

5.生成静态页面

1	$ hexo generate (或者 hexo g)

6.启动本地服务，进行测试

1	$ hexo server

7.在浏览器输入http://localhost:4000
如果能打开网页就证明上述过程全部成功了。

创建自己的WebSite

使用GitHub Pages创建自己的WebSite

在自己的GitHub主页右上角点击+ ,然后点击New respository
Repository name填写: [username].github.io(我的name是minokoko,所以我的repository name为minokoko.github.io)
到本地硬盘，刚才搭建环境第4步新建的文件夹里面(比如我建的文件夹是blog),打开_config.yml,在文件底端添加以下代码:
deploy:
type: git
repo: https://github.com/minokoko/minokoko.github.io.git (将minokoko换成自己的用户名)
branch: master
右键点击 Git Base Here,输入以下指令:
1
$ hexo generate

这样就创建一个一个public文件夹，里面包含了网页所有的静态资源。
每次部署到Github前都建议使用这个命令来保证修改的内容已经重新生成。

然后执行以下指令:
1
$ hexo deploy(也可以 hexo d)

部署到GitHub中.

在浏览器中输入:http://minokoko.github.io (minokoko换成自己的用户名)
如果能打开网页就证明上述过程全部成功了。

修改主题

完成以上过程，登录自己的网站会发现是hexo默认的模版主题，那么如何修改为自己想要的漂亮的主题呢?
下载主题
到GitHub搜索hexo,便会出现很多带有thems标签的项目,fork一个自己喜欢。
比如我想下载的主题的是next
然后在本地硬盘的blog/thems下(blog是我自己建的文件夹)，右键点击Git Base Here，输入以下指令:
1
$ git clone https://github.com/iissnan/hexo-theme-next.git
接下来到根目录下，打开_config.yml，做如下修改:
theme: next
返回根目录,执行以下命令:
1
$ hexo s --debug

好了，网站的主题就修改漂亮了。

前述