基于jsp+servlet实现的简单博客系统实例(附源码)

本文实例讲述了基于jsp+servlet实现的简单博客系统。分享给大家供大家参考。具体如下:

没有用框架写的 小博客, 代码大量重复。

个人感觉重复代码对于新手还是有好处的,我也是新手,见谅。

完整实例代码点击此处本站下载。

1. servlet

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Servlet;
import blog.BlogBean;
import blog.BlogRepositoryJDBC;
import blog.PagerUtil;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URLDecoder;
import java.util.List;
import javax.enterprise.context.RequestScoped;
import javax.enterprise.context.SessionScoped;
import javax.inject.Inject;
import javax.inject.Named;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(name = "PageListServlet", urlPatterns = {"/page/*", ""})
public class ListAllServlet extends HttpServlet {
  @Inject
  private BlogRepositoryJDBC blogdao;
  @Inject
  private PagerUtil pagerUtil;
  protected void processRequest(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    int pg;
    String s = request.getRequestURI();
    String searchContent = request.getParameter("search");
    if (s.matches(request.getContextPath() + "/page/" + "\\d")) {
      String pgnum = s.replaceAll(request.getContextPath() + "/page/", "");
      pg = Integer.parseInt(pgnum);
    } else if (s.matches(request.getContextPath() + "/")) {
      pg = 1;
    } else {
      getServletContext().getRequestDispatcher("/errorpage.jsp").forward(request, response);
      return;
    }
    List<BlogBean> bloglist;
    boolean isNullRequest = (searchContent == null || "".equals(searchContent));
    if (isNullRequest) {
      bloglist = blogdao.getBloglist();
    } else {
      bloglist = blogdao.listBlogByKey(searchContent);
    }
    if (!pagerUtil.isValidPg(bloglist, pg)) {
      getServletContext().getRequestDispatcher("/errorpage.jsp").forward(request, response);
      return;
    }
    pagerUtil.fillValue(bloglist, pg);
    String pageURLBase = getServletContext().getContextPath();
    String pageURLparam = isNullRequest ? "" : "?search=" + searchContent;
    request.setAttribute("pageURLBase", pageURLBase);
    request.setAttribute("pageURLparam", pageURLparam);
    request.setAttribute("bloglist", bloglist);
    getServletContext().getRequestDispatcher("/blog.jsp").forward(request, response);
  }
  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    processRequest(request, response);
  }
  @Override
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    processRequest(request, response);
  }
  @Override
  public String getServletInfo() {
    return "Short description";
  }// </editor-fold>
}

2. dao

package blog;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.inject.Named;
import javax.sql.DataSource;
@ApplicationScoped
@Named
public class BlogRepositoryJDBC implements BlogRepository {
  @Resource(lookup = "jdbc/sample")
  private DataSource ds;
  private ArrayList<BlogBean> bloglist;
  private Set<String> tagSet;
  private Set<String> categorySet;
  private Map<String,Integer> dateMap;
  @PostConstruct
  private void init() {
    refreshCache();
  }
  @Override
  public int addBlog(BlogBean blogi) {
    String sql = "INSERT INTO POSTS VALUES (?,?,?,?,?)";
    Connection conn = null;
    PreparedStatement ps = null;
    int out = 0;
    try {
      conn = ds.getConnection();
      ps = conn.prepareStatement(sql);
      ps.setString(1, blogi.getBlogTitle());
      ps.setString(2, blogi.getCategory());
      ps.setString(3, blogi.getTag());
      ps.setDate(4, new java.sql.Date(blogi.getPostDate().getTime()));
      ps.setString(5, blogi.getContent());
      out = ps.executeUpdate();
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ps, null);
    }
    refreshCache();
    return out;
  }
  @Override
  public int deleteBlog(String blogName) {
    String sql = "DELETE FROM POSTS WHERE HEAD = ?";
    Connection conn = null;
    PreparedStatement ps = null;
    int out = 0;
    try {
      conn = ds.getConnection();
      ps = conn.prepareStatement(sql);
      ps.setString(1, blogName);
      out = ps.executeUpdate();
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ps, null);
    }
    refreshCache();
    return out;
  }
  @Override
  public int updateBlog(BlogBean blog, String oldhead) {
    String sql = "UPDATE POSTS SET HEAD=?,CATEGORY=?,TAG=?,POSTDATE=?,CONTENT=? WHERE HEAD=?";
    PreparedStatement ps = null;
    Connection conn = null;
    int out = 0;
    try {
      conn = ds.getConnection();
      ps = conn.prepareStatement(sql);
      ps.setString(1, blog.getBlogTitle());
      ps.setString(2, blog.getCategory());
      ps.setString(3, blog.getTag());
      ps.setDate(4, new java.sql.Date(blog.getPostDate().getTime()));
      ps.setString(5, blog.getContent());
      ps.setString(6, oldhead);
      out = ps.executeUpdate();
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ps, null);
    }
    refreshCache();
    return out;
  }
  @Override
  public List<BlogBean> ListAllBlog() {
    bloglist = new ArrayList<BlogBean>();
    BlogBean blog;
    String sql = "SELECT * FROM POSTS ORDER BY POSTDATE DESC";
    Connection conn = null;
    Statement ss = null;
    ResultSet rs = null;
    int out = 0;
    try {
      conn = ds.getConnection();
      ss = conn.createStatement();
      rs = ss.executeQuery(sql);
      while (rs.next()) {
        blog = new BlogBean();
        blog.setBlogTitle(rs.getString(1));
        blog.setCategory(rs.getString(2));
        blog.setTag(rs.getString(3));
        blog.setPostDate(rs.getDate(4));
        blog.setContent(rs.getString(5));
        bloglist.add(blog);
      }
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ss, rs);
    }
    return bloglist;
  }
  @Override
  public List listBlogByKey(String keyword) {
    List<BlogBean> list = new ArrayList<BlogBean>();
    BlogBean blog;
    String sql = "SELECT * FROM POSTS WHERE HEAD LIKE ? ORDER BY POSTDATE DESC";
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    int out = 0;
    try {
      conn = ds.getConnection();
      ps = conn.prepareStatement(sql);
      ps.setString(1, "%" + keyword + "%");
      rs = ps.executeQuery();
      while (rs.next()) {
        blog = new BlogBean();
        blog.setBlogTitle(rs.getString(1));
        blog.setCategory(rs.getString(2));
        blog.setTag(rs.getString(3));
        blog.setPostDate(rs.getDate(4));
        blog.setContent(rs.getString(5));
        list.add(blog);
      }
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ps, rs);
    }
    return list;
  }
  @Override
  public List listBlogByContent(String keyword) {
    List<BlogBean> list = new ArrayList<BlogBean>();
    BlogBean blog;
    String sql = "SELECT * FROM POSTS WHERE CONTENT LIKE ? ORDER BY POSTDATE DESC";
    PreparedStatement ps = null;
    ResultSet rs = null;
    Connection conn = null;
    int out = 0;
    try {
      conn = ds.getConnection();
      ps = conn.prepareStatement(sql);
      ps.setString(1, "%" + keyword + "%");
      rs = ps.executeQuery();
      while (rs.next()) {
        blog = new BlogBean();
        blog.setBlogTitle(rs.getString(1));
        blog.setCategory(rs.getString(2));
        blog.setTag(rs.getString(3));
        blog.setPostDate(rs.getDate(4));
        blog.setContent(rs.getString(5));
        list.add(blog);
      }
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ps, rs);
    }
    return list;
  }
  public Set listAllTags() {
    tagSet = new HashSet<String>();
    String sql = "SELECT TAG FROM POSTS ";
    Connection conn = null;
    Statement ss = null;
    ResultSet rs = null;
    try {
      conn = ds.getConnection();
      ss = conn.createStatement();
      rs = ss.executeQuery(sql);
      while (rs.next()) {
        String tags = rs.getString(1);
        String[] Arraytags = tags.split(",");
        tagSet.addAll(Arrays.asList(Arraytags));
      }
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ss, rs);
    }
    return tagSet;
  }
  public List listBlogByTag(String keyword) {
    List<BlogBean> list = new ArrayList<BlogBean>();
    BlogBean blog;
    String sql = "SELECT * FROM POSTS WHERE TAG LIKE ? ORDER BY POSTDATE DESC";
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    int out = 0;
    try {
      conn = ds.getConnection();
      ps = conn.prepareStatement(sql);
      ps.setString(1, "%" + keyword + "%");
      rs = ps.executeQuery();
      while (rs.next()) {
        blog = new BlogBean();
        blog.setBlogTitle(rs.getString(1));
        blog.setCategory(rs.getString(2));
        blog.setTag(rs.getString(3));
        blog.setPostDate(rs.getDate(4));
        blog.setContent(rs.getString(5));
        list.add(blog);
      }
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ps, rs);
    }
    return list;
  }
    public List listBlogByDate(String keyword) {
    List<BlogBean> list = new ArrayList<BlogBean>();
    BlogBean blog;
    String sql = "SELECT * FROM POSTS WHERE POSTDATE = ? ORDER BY POSTDATE DESC";
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    int out = 0;
    try {
      conn = ds.getConnection();
      ps = conn.prepareStatement(sql);
      ps.setString(1, keyword );
      rs = ps.executeQuery();
      while (rs.next()) {
        blog = new BlogBean();
        blog.setBlogTitle(rs.getString(1));
        blog.setCategory(rs.getString(2));
        blog.setTag(rs.getString(3));
        blog.setPostDate(rs.getDate(4));
        blog.setContent(rs.getString(5));
        list.add(blog);
      }
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ps, rs);
    }
    return list;
  }
  public Set listAllCategory() {
    categorySet = new HashSet<String>();
    String sql = "SELECT CATEGORY FROM POSTS";
    Connection conn = null;
    Statement ss = null;
    ResultSet rs = null;
    try {
      conn = ds.getConnection();
      ss = conn.createStatement();
      rs = ss.executeQuery(sql);
      while (rs.next()) {
        String category = rs.getString(1);
        categorySet.add(category);
      }
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ss, rs);
    }
    return categorySet;
  }
  public List listBlogByCategory(String keyword) {
    List<BlogBean> list = new ArrayList<BlogBean>();
    BlogBean blog;
    String sql = "SELECT * FROM POSTS WHERE CATEGORY LIKE ?";
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    int out = 0;
    try {
      conn = ds.getConnection();
      ps = conn.prepareStatement(sql);
      ps.setString(1, "%" + keyword + "%");
      rs = ps.executeQuery();
      while (rs.next()) {
        blog = new BlogBean();
        blog.setBlogTitle(rs.getString(1));
        blog.setCategory(rs.getString(2));
        blog.setTag(rs.getString(3));
        blog.setPostDate(rs.getDate(4));
        blog.setContent(rs.getString(5));
        list.add(blog);
      }
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ps, rs);
    }
    return list;
  }
  private void fillDateMap(){
    String sql = "SELECT POSTDATE,COUNT(POSTDATE) FROM POSTS GROUP BY POSTDATE";
     Connection conn = null;
    Statement ss = null;
    ResultSet rs = null;
    dateMap = new HashMap<String,Integer>();
    try {
      conn = ds.getConnection();
      ss = conn.createStatement();
       rs=ss.executeQuery(sql);
      while (rs.next()) {
        dateMap.put(rs.getString(1), rs.getInt(2));
      }
    } catch (SQLException ex) {
      Logger.getLogger(BlogRepositoryJDBC.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
      closeEverything(conn, ss, rs);
    }
  }
  public void test(){
        for(Map.Entry<String,Integer> dd: dateMap.entrySet()){
           dd.getKey();
           dd.getValue();
        }
  }
  public void refreshCache() {
    ListAllBlog();
    listAllTags();
    listAllCategory();
    fillDateMap();
  }
  public ArrayList<BlogBean> getBloglist() {
    return bloglist;
  }
  public Set<String> getTagSet() {
    return tagSet;
  }
  public Set<String> getCategorySet() {
    return categorySet;
  }
  public Map<String, Integer> getDateMap() {
    return dateMap;
  }
  private void closeEverything(Connection conn, Statement ps, ResultSet rs) {
    if (rs != null) {
      try {
        rs.close();
      } catch (SQLException ex) {
      }
    }
    if (ps != null) {
      try {
        ps.close();
      } catch (SQLException ex) {
      }
    }
    if (conn != null) {
      try {
        conn.close();
      } catch (SQLException ex) {
      }
    }
  }
}

3. 运行效果截图:

希望本文所述对大家的JSP程序设计有所帮助。

时间: 2015-09-18

利用JS生成博文目录及CSS定制博客

本文实例为大家介绍了利用JS生成博文目录及CSS定制博客的方法,分享给大家供大家参考,具体内容如下 1.JS代码 想要生成目录,许多都说需要JS修改权限,那个这里就直接进入设置页面,找到下方的联系邮箱直接发去就行了,工作人员回复的还是很快的. 拿到权限之后,下面就是将编(搜)写(寻)的JS代码放在页脚HTML代码的方框内,然后点击保存就可以了.要注意目录的生成是几级标题,这一点可是很重要的.JS代码如下,基本没有变化,拷贝了原作者的写法,可以生成二级目录,分别为h2和h3,这点需要注意. 综合来

用js实现博客打赏功能

前几天在一个博客中看到有一个打赏功能.其实简单说来就是在页面中加入动态DOM节点,使用的也是简单的HTML.CSS.JS这些前端的一些简单知识.在GitHub上有开源的代码,这里稍加改造就可以用在自己的博客中了. 最简单的使用方式是在页面中加入如下JS代码: <script> window.tctipConfig = { staticPrefix: "http://static.tctip.com", buttonImageId: 1, buttonTip: "z

用js实现的仿sohu博客更换页面风格(简单版)

复制代码 代码如下: prowin.js /** * @author ldgmc */ function PopWin(id,width,title){     this.id=id;     this.width=width;     this.title=title;     this.createIns=function(){         var ins=document.createElement("div");         ins.className="po

js 博客内容进度插件详解

前面的话 最近在复习自己写的博客,但有的博客内容很长,长到不知道多少时间可以读完.这时,就有种泄气的冲动.但,如果能够提供一个博客内容进度的插件,根据所读内容的多少,显示进度条,让自己对所读的内容进度心里有数,可以让自己平静下来,一点一点读下去.本文将详细介绍博客内容进度插件的实现 效果演示 无论是通过鼠标滚轮,还是拖动滚动条,也或者是按空格键,只要发生了页面的滚动操作,就会触发页面底部博客内容进度条的变化.根据当前内容的多少计算与博客所有内容的比例,最终对应成进度条的宽度.当鼠标移入进度条范围

node.js实现博客小爬虫的实例代码

前言 爬虫,是一种自动获取网页内容的程序.是搜索引擎的重要组成部分,因此搜索引擎优化很大程度上就是针对爬虫而做出的优化. 这篇文章介绍的是利用node.js实现博客小爬虫,核心的注释我都标注好了,可以自行理解,只需修改url和按照要趴的博客内部dom构造改一下filterchapters和filterchapters1就行了! 下面话不多说,直接来看实例代码 var http=require('http'); var Promise=require('Bluebird'); var cheeri

js使用ajax读博客rss示例

复制代码 代码如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>this is test</tit

javascript实现博客园页面右下角返回顶部按钮

博客园中很多博友的博客中在Page右下角都有个图标,不论屏幕怎么拉伸,都始终停留在右下角.点击后页面置顶.后面想想写一个Demo来实现这种效果吧. 一. 图标右下角固定. 1.SS 里面提供了4中布局方式. 其中fixed表示绝对定位元素.所以我们选择使用fixed来实现图标固定. absolute 生成绝对定位的元素,相对于 static 定位以外的第一个父元素进行定位. 元素的位置通过 "left", "top", "right" 以及 &q

博客侧边栏模块跟随滚动条滑动固定效果的实现方法(js+jquery等)

当一个页面内容很长的时候,侧边栏栏目可能显得太短,当窗口滑动到靠下的位置,则侧边即失去了展示内容的机会.很多新闻资讯类网站如新浪.网易.CSDN等,会在边栏的右下角以固定的小弹窗形式,以提供更多的内容展示方式,但这并不适合博客和web2.0风格的网站. 现在很多的独立博客和网站如人人网等,都使用了让侧边栏模块随滚动条滑动而位置固定的效果.就是当一个页面很长的时候,设定侧栏内容会跟随滚动条,这种效果适用于评论较多.内容较长的网站.志文工作室调研了几种类似功能的实现方法,摘录之以供参考. 参考一.提

JS实现新浪博客左侧的Blog管理菜单效果代码

本文实例讲述了JS实现新浪博客左侧的Blog管理菜单效果代码.分享给大家供大家参考,具体如下: 这里介绍新浪博客左侧的Blog管理菜单,我们变通一下,如果你在设计程序,那么本款菜单用到后台管理中想必应该很合适吧,图片是调用新浪的,用了比较多的图片,你用的时候最好是下载到本地,以免新浪哪天改版了,你就傻了. 运行效果截图如下: 在线演示地址如下: http://demo.jb51.net/js/2015/js-sina-blog-left-menu-style-codes/ 具体代码如下: <ht

nodejs个人博客开发第七步 后台登陆

本文为大家分享了nodejs个人博客开发的后台登陆,具体内容如下 定义后台路径 访问这个路径进入后台页面 http://localhost:8888/admin/login 在后台路由控制器里面(/admin/index.js)调用登陆控制器(/admin/login.js) //调用router对象的use方法,使用路由中间件 router.use("/login",require("./login")); 登陆控制器里面,定义登陆界面的路由,定义登陆提交验证的路

nodejs个人博客开发第五步 分配数据

本文为大家分享了nodejs个人博客开发的分配数据,具体内容如下 使用回掉大坑进行取数据 能看明白的就看,看不明白的手动滑稽 /** * 首页控制器 */ var router=express.Router(); /*每页条数*/ var pageSize=5; router.get('/',function(req,res,next){ var currentPage=parseInt(req.params.page); var cid=0; var categoryModel=F.model

nodejs个人博客开发第六步 数据分页

本文为大家分享了nodejs个人博客开发的数据分页,具体内容如下 控制器路由定义 首页路由:http://localhost:8888/ 首页分页路由:http://localhost:8888/index/2 /** * 首页控制器 */ var router=express.Router(); /*每页条数*/ var pageSize=4; /*首页*/ router.get('/',function(req,res,next){ var cid=0; F.model("article&q

nodejs个人博客开发第四步 数据模型

本文为大家分享了nodejs个人博客开发的数据模型,具体内容如下 数据库模型 /model/db.js 数据库操作类,完成链接数据库和数据库的增删查改 查询表 /*查询*/ select:function(tableName,callback,where,field){ field=field ? field : '*'; var sql="select "+field+" from "+this.C.DB_PRE+tableName; if(where){ sql

nodejs个人博客开发第三步 载入页面

本文为大家分享了nodejs个人博客开发的载入页面,具体内容如下 模板引擎 使用ejs作为我们博客的前端模板引擎,用来从json数据生成html字符串 安装:npm install ejs -save 使用:入口文件中写入下面代码,定义/view/目录为视图目录 /*模板引擎*/ application.set('views',__dirname+'/views'); application.engine('.html',require("ejs").__express); appli

nodejs个人博客开发第二步 入口文件

本文为大家分享了nodejs个人博客开发的入口文件,具体内容如下 错误处理中间件 定义错误处理中间件必须使用4个参数,否则会被作为普通中间件 /*错误处理器*/ application.use(function(err,req,res,next){ console.error(err.stack); res.status(500).send("代码出错了,错误信息:<br/>"+err.stack); }); /*404*/ application.use(function

nodejs个人博客开发第一步 准备工作

前言 nodejs是运行在服务端的js,基于google的v8引擎.个人博客系统包含对数据库的增删查改,功能齐备,并且业务逻辑比较简单,是很多后台程序员为了检测学习成果,最先拿来练手的小网站程序.我也是在去年年末接触的nodejs,接下来随便纪录一下这个小blog的功能点和注意事项. 语言和环境 1. 进入nodejs的官方网站,下载nodejs运行环境 下载安装完成以后是这个样子的 2. express是基于nodejs平台的web开发框架,进入express框架的官方网站,了解express

node.js博客项目开发手记

需要安装的模块 body-parser 解析post请求 cookies 读写cookie express 搭建服务器 markdown Markdown语法解析生成器 mongoose 操作Mongodb数据库 swig 模板解析引擎 目录结构 db 数据库存储目录 models 数据库模型文件目录 public 公共文件目录(css,js,img) routers 路由文件目录 schemas 数据库结构文件 views 模板视图文件目录 app.js 启动文件 package.json a

python爬虫 正则表达式使用技巧及爬取个人博客的实例讲解

这篇博客是自己<数据挖掘与分析>课程讲到正则表达式爬虫的相关内容,主要简单介绍Python正则表达式爬虫,同时讲述常见的正则表达式分析方法,最后通过实例爬取作者的个人博客网站.希望这篇基础文章对您有所帮助,如果文章中存在错误或不足之处,还请海涵.真的太忙了,太长时间没有写博客了,抱歉~ 一.正则表达式 正则表达式(Regular Expression,简称Regex或RE)又称为正规表示法或常规表示法,常常用来检索.替换那些符合某个模式的文本,它首先设定好了一些特殊的字及字符组合,通过组合的&

CentOS下搭建PHP环境与WordPress博客程序的全流程总结

环境 服务器操作系统:CentOS 7.0 博客部署服务器:Apache 后台语言:PHP 数据库:MySql 前端框架:WordPress 步骤 一.安装Apache 安装 Apache 很简单,只需要在终端输入以下命令就可以了: sudo yum install httpd sudo 的意思是用 root 用户做什么操作,yum install 是在线安装:然后输入 yes 就确认下载安装了. 安装完毕之后我们需要启动服务: sudo service httpd start 当启动服务器完成