Garry1115
Garry1115

java web 个人博客系统

源码免费下载地址：关注微信公众号“虾米聊吧”，回复关键字“博客”

 

推荐更完善功能更强大的java web个人博客系统高级版：https://blog.csdn.net/zwx19921215/article/details/102665020

 

最近利用闲暇时间简单重构了一个java web版本的个人博客系统项目（参考codingyun），属于前后端一体的项目，前端jsp，后端为springmvc + spring jdbc,简单易用好上手！

一个基本的个人博客系统包括：文章、分类、用户等基本功能。

目前设计的数据库表：文章表、分类表、系统用户表、前端用户表；（后续会继续完善）、

 

效果图如下：

前端文章列表展示页（风格样式我是参考的）

java web 个人博客系统_第1张图片

 

留言页

java web 个人博客系统_第2张图片

 

关于页面

java web 个人博客系统_第3张图片

文章详情页

java web 个人博客系统_第4张图片

 

后台登录页

java web 个人博客系统_第5张图片

后台管理

java web 个人博客系统_第6张图片

项目结构

java web 个人博客系统_第7张图片

文章管理Controller：

package com.xiaofeng.blog.action.system;

import com.google.gson.Gson;
import com.xiaofeng.blog.action.BaseController;
import com.xiaofeng.blog.entity.JsonResult;
import com.xiaofeng.blog.entity.PageBean;
import com.xiaofeng.blog.entity.QueryCondition;
import com.xiaofeng.blog.entity.bo.BlogArticleBo;
import com.xiaofeng.blog.entity.vo.BlogArticleVo;
import com.xiaofeng.blog.exception.ServiceException;
import com.xiaofeng.blog.service.BlogArticleService;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

@Controller
@RequestMapping("/system/article")
public class SysArticleController extends BaseController {
	
	private static Logger logger = Logger.getLogger(SysArticleController.class);
	
	@Autowired
	private BlogArticleService blogArticleService;
	
	@RequestMapping(value = "", method = RequestMethod.GET)
	public String getArticleList(HttpServletRequest request, QueryCondition queryCondition) throws Exception{
		PageBean blogArticlePageBean = null;
		try{
			blogArticlePageBean = blogArticleService.getSysArticleList(queryCondition);
		} catch (Exception e){
			e.printStackTrace();
		}
		request.setAttribute("articleList", blogArticlePageBean !=null ? blogArticlePageBean.getDatas() : null);
		request.setAttribute("pageInfo", blogArticlePageBean);
		request.setAttribute("queryCondition" , queryCondition);
		logger.info("get articleList size:" + blogArticlePageBean.getDatas().size());
		return "system/blogArticleList";
	}
	
	@RequestMapping(value = "addArticle", method = RequestMethod.POST)
	@ResponseBody
	public Object addArticle(HttpServletRequest request, BlogArticleBo article){
		logger.info("addArticle info:" + article.toString());
		boolean flag = false;
		String errorMessage = "新增文章成功!";
		try{
			flag = blogArticleService.addArticle(article);
		}catch (ServiceException serviceE){
			logger.error("addArticle failed!" , serviceE);
			errorMessage = serviceE.getMessage();
		}catch (Exception e){
			logger.error("addArticle failed!" , e);
			errorMessage = "新增文章失败!";
		}
		if(flag){
			return "";
		}
		return "";
	}
	
	@RequestMapping(value = "updateArticle", method = RequestMethod.POST)
	@ResponseBody
	public Object updateArticle(HttpServletRequest request, BlogArticleBo article){
		logger.info("updateArticle info:" + article.toString());
		boolean flag = false;
		String errorMessage = "修改文章成功!";
		try{
			flag = blogArticleService.updateArticle(article);
		}catch (ServiceException serviceE){
			logger.error("updateArticle failed!" , serviceE);
			errorMessage = serviceE.getMessage();
		}catch (Exception e){
			logger.error("updateArticle failed!" , e);
			errorMessage = "修改文章失败!";
		}
		if(flag){
			return "";
		}
		return "";
	}
	
	@RequestMapping(value = "uploadJson", method = RequestMethod.POST)
	@ResponseBody
	public String uploadJson(HttpServletRequest request , HttpServletResponse response, BlogArticleVo blogArticleVo){
		Map returnMap = new HashMap();
		try {
			returnMap.put("error", 0);
			returnMap.put("url", blogArticleService.saveArticleImg(blogArticleVo));
		} catch (Exception e) {
			returnMap.put("error", 1);
			returnMap.put("message", "图片格式不正确");
			return new Gson().toJson(returnMap);
		}
		return new Gson().toJson(returnMap);
	}
	
	@RequestMapping(value = "getArticleByArticleId", method = RequestMethod.POST)
	@ResponseBody
	public String getArticleByArticleId(HttpServletRequest request, @RequestBody BlogArticleVo blogArticleVo) throws Exception{
		JsonResult jsonResult = new JsonResult();
		BlogArticleBo blogArticleBo = blogArticleService.getArticleById(blogArticleVo.getId());
		jsonResult.setResultCode(0);
		jsonResult.setResultMessage("获取文章内容成功");
		jsonResult.setData(blogArticleBo);
		return new Gson().toJson(jsonResult);
	}
	
	@RequestMapping(value = "del", method = RequestMethod.POST)
	@ResponseBody
	public String del(HttpServletRequest request,@RequestBody BlogArticleVo blogArticleVo){
		logger.info("del info:" + blogArticleVo.toString());
		boolean flag = false;
		String errorMessage = "删除文章失败";
		JsonResult jsonResult = new JsonResult();
		try{
			flag = blogArticleService.delArticle(blogArticleVo.getId());
		}catch (ServiceException serviceE){
			logger.error("del article failed!", serviceE);
			errorMessage = serviceE.getMessage();
		}catch (Exception e) {
			logger.error("del article failed!", e);
		}
		jsonResult.setResultCode(flag ? 0 : 1);
		jsonResult.setResultMessage(flag ? "删除文章成功" : errorMessage);
		return new Gson().toJson(jsonResult);
	}

}

文章管理service:

package com.xiaofeng.blog.service.impl;

import com.xiaofeng.blog.constant.ConstantUtil;
import com.xiaofeng.blog.dao.BlogArticleDao;
import com.xiaofeng.blog.entity.PageBean;
import com.xiaofeng.blog.entity.QueryCondition;
import com.xiaofeng.blog.entity.bo.BlogArticleBo;
import com.xiaofeng.blog.entity.vo.BlogArticleVo;
import com.xiaofeng.blog.service.BlogArticleService;
import com.xiaofeng.blog.service.UploadFileService;
import com.xiaofeng.blog.util.DateUtil;
import com.xiaofeng.blog.util.MD5Util;
import org.apache.commons.io.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.util.Date;
import java.util.List;

@Service
public class BlogArticleServiceImpl implements BlogArticleService {

    private static final Logger logger = LoggerFactory.getLogger(BlogArticleServiceImpl.class);

    @Autowired
    private BlogArticleDao blogArticleDao;
    @Autowired
    private UploadFileService uploadFileService;

    @Override
    public PageBean getArticleList(QueryCondition queryCondition) throws Exception {
        queryCondition.setPageSize("15");
        return blogArticleDao.getArticleList(queryCondition);
    }

    @Override
    public PageBean getSysArticleList(
            QueryCondition queryCondition) throws Exception {
        queryCondition.setPageSize("15");
        return blogArticleDao.getSysArticleList(queryCondition);
    }

    @Override
    public boolean siteMapFile(QueryCondition queryCondition) throws Exception {
        List articleList = blogArticleDao.getArticleList(queryCondition).getDatas();
        StringBuilder sb = new StringBuilder();
        for (BlogArticleVo article : articleList) {
            sb.append("http://www.xiaofeng.com/article/" + article.getId() + ".html");
            sb.append("\r\n");
        }
//		File file = new File("F:"+File.separator+"test"+File.separator+"siteMap.txt"); 
        File file = new File("/alidata/dataFile/sitemap.txt");
        FileUtils.writeStringToFile(file, sb.substring(0, sb.length() - 2));
        return true;
    }

    @Override
    public PageBean getTagArticleList(
            QueryCondition queryCondition, String tag) throws Exception {
        return blogArticleDao.getTagArticleList(queryCondition, tag);
    }

    @Override
    public PageBean getArticleList(int category, QueryCondition queryCondition)
            throws Exception {
        return blogArticleDao.getArticleList(category, queryCondition);
    }

    @Override
    public boolean addArticle(BlogArticleBo article) throws Exception {
        article.saveVlidate();
        if (article.getContent().indexOf("", 200) > 0) {
                article.setContentDesc(article.getContent().substring(0, article.getContent().indexOf("
", 200)));
            } else {
                article.setContentDesc(article.getContent());
            }
        } else {
            article.setContentDesc(article.getContent());
        }
        article.setContent(article.getContent().replace("
", "
") + ConstantUtil.ARTICLE_FOOTER_ADD);
        return blogArticleDao.addArticle(article);
    }

    @Override
    public boolean updateArticle(BlogArticleBo article) throws Exception {
        article.saveVlidate();
        if (article.getContent().indexOf("", 200) > 0) {
                article.setContentDesc(article.getContent().substring(0, article.getContent().indexOf("
", 200)));
            } else {
                article.setContentDesc(article.getContent());
            }
        } else {
            article.setContentDesc(article.getContent());
        }
//		article.setContent(article.getContent() + ConstantUtil.ARTICLE_FOOTER_ADD);
        article.setContent(article.getContent().replace("
", "
"));
        return blogArticleDao.updateArticle(article, new String[]{"title", "content", "contentDesc", "category", "showFlag", "tag", "keyWords", "description"});
    }

    @Override
    public boolean delArticle(int articleId) throws Exception {
        return blogArticleDao.delArticle(articleId);
    }

    @Override
    public BlogArticleVo getArticleById(int articleId) throws Exception {
        BlogArticleVo article = blogArticleDao.getArticleById(articleId);
        if (article != null) {
            article.setUserReadCount(article.getUserReadCount() + 1);
            BlogArticleBo articleBo = new BlogArticleBo();
            BeanUtils.copyProperties(article, articleBo);
            blogArticleDao.updateArticle(articleBo, "userReadCount");
        }
        return article;
    }

    @Override
    public String saveArticleImg(BlogArticleVo blogArticleVo)
            throws Exception {
        String realPath = ConstantUtil.DATA_REAL_PATH_ARTICLE_IMG;
        String path = ConstantUtil.SERVER_URL + "/articleDirectory/";   //www.xiaofeng.com/articleDirectory/supernatural.jpg
        MultipartFile multipartFile = blogArticleVo.getImgFile();
        String fileName = MD5Util.GetMD5Code("" + DateUtil.getTimeInMillis(new Date())) +
                multipartFile.getOriginalFilename().substring(multipartFile.getOriginalFilename().lastIndexOf("."));
        logger.info("upload handout imgfile url:" + realPath);
        uploadFileService.uploadFile(realPath, multipartFile, fileName);
        return path + fileName;
    }

}

 
  
文章管理Dao：
 
  
package com.xiaofeng.blog.dao.impl;

import com.xiaofeng.blog.dao.BlogArticleDao;
import com.xiaofeng.blog.dao.GeneralDao;
import com.xiaofeng.blog.entity.PageBean;
import com.xiaofeng.blog.entity.QueryCondition;
import com.xiaofeng.blog.entity.bo.BlogArticleBo;
import com.xiaofeng.blog.entity.vo.BlogArticleVo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository
public class BlogArticleDaoImpl implements BlogArticleDao {
	
	private static Logger logger = LoggerFactory.getLogger(BlogArticleDaoImpl.class);
	
	@Autowired
	private GeneralDao generalDao;

	@Override
	public PageBean getArticleList(QueryCondition queryCondition) throws Exception {
		return generalDao.getPageBeans(
				BlogArticleVo.class, 
				" SELECT article.*, category.categoryName FROM blog_article article LEFT JOIN `category` category ON article.`category` = category.`id` WHERE article.showFlag = ? ORDER BY article.ID DESC ", 
				Integer.parseInt(queryCondition.getPageNo()), 
				Integer.parseInt(queryCondition.getPageSize()), 
				new Object[]{1});
	}
	
	@Override
	public PageBean getSysArticleList(QueryCondition queryCondition) throws Exception {
		return generalDao.getPageBeans(
				BlogArticleVo.class, 
				" select * from blog_article ORDER BY ID DESC ", 
				Integer.parseInt(queryCondition.getPageNo()), 
				Integer.parseInt(queryCondition.getPageSize()),  
				new Object[]{});
	}

	@Override
	public PageBean getTagArticleList(
			QueryCondition queryCondition, String tag) throws Exception {
		return generalDao.getPageBeans(
				BlogArticleVo.class, 
				" SELECT article.*, category.categoryName FROM blog_article article LEFT JOIN `category` category ON article.`category` = category.`id` "
						+ " WHERE article.showFlag = ? and article.tag like ? ORDER BY article.userReadCount DESC ",
				Integer.parseInt(queryCondition.getPageNo()), 
				Integer.parseInt(queryCondition.getPageSize()), 
				new Object[]{1, "%"+ tag +"%"});
	}
	
	@Override
	public PageBean getArticleList(int category, QueryCondition queryCondition)
			throws Exception {
		logger.info("getArticleList");
		return generalDao.getPageBeans(
				BlogArticleVo.class, 
				" SELECT article.*, category.categoryName FROM blog_article article LEFT JOIN `category` category ON article.`category` = category.`id` "
				+ " WHERE article.showFlag = ? and article.category = ? ORDER BY article.ID DESC ",
				Integer.parseInt(queryCondition.getPageNo()), 
				Integer.parseInt(queryCondition.getPageSize()), 
				new Object[]{1, category});
	}

	@Override
	public boolean addArticle(BlogArticleBo article) throws Exception {
		return generalDao.saveEntity(article);
	}

	@Override
	public boolean updateArticle(BlogArticleBo article, String...updateFields) throws Exception {
		return generalDao.updateEntity(article, updateFields);
	}

	@Override
	public boolean delArticle(int articleId) throws Exception {
		BlogArticleBo bo = new BlogArticleBo();
		bo.setId(articleId);
		return generalDao.delEntity(bo);
	}

	@Override
	public BlogArticleVo getArticleById(int articleId) throws Exception {
		return generalDao.getEntity(
				BlogArticleVo.class, 
				" SELECT article.*, category.categoryName FROM blog_article article LEFT JOIN `category` category ON article.`category` = category.`id` WHERE article.id = ?", 
				new Object[]{articleId});
	}
}

 
  
GeneralDaoImpl：
 
  
package com.xiaofeng.blog.dao.impl;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.xiaofeng.blog.constant.TableConstant;
import com.xiaofeng.blog.dao.GeneralDao;
import com.xiaofeng.blog.entity.PageBean;
import com.xiaofeng.blog.exception.DaoException;
import com.xiaofeng.blog.util.ObjectUtil;
import com.xiaofeng.blog.util.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.ArgumentPreparedStatementSetter;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ParameterDisposer;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.stereotype.Repository;

@Repository
public class GeneralDaoImpl implements GeneralDao {
	
	private static Logger logger = LoggerFactory.getLogger(GeneralDaoImpl.class);
	

	/**
	 * 在讲解依赖注入的3种实现方式之前，这里先澄清一下依赖注入的意义：
	 * 让组件依赖于抽象，当组件要与其他实际对象发生依赖关系时，通过抽象来注入依赖的实际对象。 
	 * 依赖注入的3种实现方式分别是：接口注入（interface injection）、Set注入（setter injection）和构造注入（constructor injection）。
	 */
	@Autowired
	private JdbcTemplate jdbcTemplate;

	@Override
	public  List getEntityList(Class beanClass, String sql, Object[] values) throws Exception{
		List beanList = new ArrayList();
		try{
			beanList = jdbcTemplate.query(sql.toString(), BeanPropertyRowMapper.newInstance(beanClass), values);
		}catch (DataAccessException e){
			logger.error("GeneralDao getEntityList has failed!" + e);
		}
		return beanList;
	}
	
	@Override
	public PageBean getPageBeans(Class beanClass, String sql, int pageNo, int pageSize, Object...objs) throws Exception{
		PageBean page = new PageBean();
		if(pageNo<1){
			pageNo = 1;
		}
		if(pageSize<1){
			pageSize = 10;
		}
		try {
			sql = sql.toLowerCase();
			String countsql = " select count(1) " + sql.substring(sql.indexOf("from"));
			Integer count = jdbcTemplate.queryForObject(countsql, objs, Integer.class);
			String limitsql = sql+" limit "+(pageNo-1)*pageSize +","+pageSize;
			List dataList = (List) getEntityList(beanClass, limitsql, objs);
			page.setPageNo(pageNo+"");
			page.setPageSize(pageSize);
			page.setRowsCount(count != null ? count.intValue() : 0);
			page.setDatas(dataList);
		} catch (SQLException e) {
			e.printStackTrace();
			return null;
		}
		return page;
	}

	@Override
	public  T getEntity(Class beanClass, String sql, Object[] values)
			throws Exception {
		List beanList = null;
		try{
//			bean = jdbcTemplate.queryForObject(sql.toString(), BeanPropertyRowMapper.newInstance(beanClass), values);
			beanList = jdbcTemplate.query(sql.toString(), BeanPropertyRowMapper.newInstance(beanClass), values);
		}catch(EmptyResultDataAccessException e){
			return null;
		}catch(DataAccessException e){
			logger.error("GeneralDao getEntity with sql has failed!"+ sql + e);
		}
		return beanList != null && beanList.size() > 0 ? beanList.get(0) : null;
	}
	
	
	/**
	 * 通过主键值查出对象
	 * @param beanClass 
	 * @param primaryKeyValue 主键的值，根据该值查出对象数据
	 */
	@Override
	public  T getEntity(Class beanClass, Object primaryKeyValue) throws Exception{
		T bean = null;
		String tableName = TableConstant.TABLE_BEAN.get(beanClass.getName());
		String primaryKey = TableConstant.TABLE_PRIMARY_KEY.get(tableName);
		if(StringUtil.isEmpty(tableName)){
			logger.info("对象实体bean未与数据库表名称映射，请维护TableConstant.java");
			return null;
		}
		if(StringUtil.isEmpty(primaryKey)){
			logger.info("数据库表名称未与表主键字段映射，请维护TableConstant.java");
			return null;
		}
		StringBuilder sql = new StringBuilder(" select * from ");
		sql.append(tableName).append(" where ").append(primaryKey).append(" = ? ");
		try{
			bean = jdbcTemplate.queryForObject(sql.toString(), BeanPropertyRowMapper.newInstance(beanClass), primaryKeyValue);
		}catch(EmptyResultDataAccessException e){
			logger.info("There is no result,Incorrect result size: expected 1, actual 0");
			return null;
		}catch (DataAccessException e){
			logger.error("GeneralDao getEntity by primaryKeyValue has failed!" + e);
		}
		return bean;
	}
	
	/**
	 * 获取Map集合值
	 * @param sql
	 * @param obj
	 * @return
	 */
	@Override
	public Map getMap(String sql,Object[] obj) throws Exception{
		
		Map map = null;
		try {
			map = jdbcTemplate.queryForMap(sql, obj);
		} catch (Exception e) {
			logger.info("获取Map集合值失败！" + e);
			throw new DaoException("数据库操作失败！",e);
		}
		return map;
	}

	@Override
	public boolean delEntity(Object entity) throws Exception {
		String tableName = TableConstant.TABLE_BEAN.get(entity.getClass().getName());
		String primaryKey = TableConstant.TABLE_PRIMARY_KEY.get(tableName);
		if(StringUtil.isEmpty(tableName)){
			logger.info("对象实体bean未与数据库表名称映射，请维护TableConstant.java");
			return false;
		}
		if(StringUtil.isEmpty(primaryKey)){
			logger.info("数据库表名称未与表主键字段映射，请维护TableConstant.java");
			return false;
		}
		StringBuilder sql = new StringBuilder(" delete from ");
		sql.append(tableName).append(" where ");
		sql.append(primaryKey).append(" = ? ");
		List objList = new ArrayList();
		PropertyDescriptor pd = new PropertyDescriptor(primaryKey, entity.getClass());   
        Method getMethod = pd.getReadMethod();  //获得get方法   
        Object primaryKeyValue = getMethod.invoke(entity);
		objList.add(primaryKeyValue);
//		try{
//			int returnFlag = jdbcTemplate.update(sql.toString(), objList.toArray());
//			logger.info("returnFlag:" + returnFlag);
//		}catch(DataAccessException e){
//			logger.error("GeneralDao delEntity by has failed!" + e);
//			delFlag = false;
//		}
//		return delFlag;
		return delEntityBySql(sql.toString(), objList.toArray());
	}
	
	@Override
	public boolean delEntityBySql(String sql, final Object... objs) throws Exception{
		boolean delFlag = true;
		try{
			int returnFlag = jdbcTemplate.update(sql.toString(), objs);
			logger.info("returnFlag:" + returnFlag);
		}catch(DataAccessException e){
			logger.error("GeneralDao delEntity by has failed!" + e);
			delFlag = false;
		}
		return delFlag;
	}
//	
//	@Override
//	public boolean saveEntity(String sql, Object obj) throws Exception {
//		return addOrUpdate(sql, obj);
//	}
	
	@Override
	public int saveEntityReturnKey(String insertSql, final Object... params) throws Exception {
		final String sql = insertSql;
        KeyHolder keyHolder = new GeneratedKeyHolder();
        jdbcTemplate.update(new PreparedStatementCreator() {
            public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
                PreparedStatement ps = con.prepareStatement(sql, 
						PreparedStatement.RETURN_GENERATED_KEYS);
				PreparedStatementSetter pss = new ArgumentPreparedStatementSetter(params);
				try {
					if (pss != null) {
						pss.setValues(ps);
					}
				} finally {
					if (pss instanceof ParameterDisposer) {
						((ParameterDisposer) pss).cleanupParameters();
					}
				}
				return ps;
            }
            
        }, keyHolder);
        logger.info("GeneralDao saveEntityReturnKey the primaryKey is:" + keyHolder.getKey().intValue());
        return keyHolder.getKey().intValue();
	}
	
	@Override
	public int saveEntityReturnKeyHolder(String insertSql, final Object... params) throws Exception {
		final String sql = insertSql;
		KeyHolder keyHolder = new GeneratedKeyHolder();
		jdbcTemplate.update(new PreparedStatementCreator() {
			public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
				PreparedStatement ps = con.prepareStatement(sql, 
						new String[]{"id"});
				PreparedStatementSetter pss = new ArgumentPreparedStatementSetter(params);
				try {
					if (pss != null) {
						pss.setValues(ps);
					}
				} finally {
					if (pss instanceof ParameterDisposer) {
						((ParameterDisposer) pss).cleanupParameters();
					}
				}
				return ps;
			}
			
		}, keyHolder);
		logger.info("GeneralDao saveEntityReturnKey the primaryKey is:" + keyHolder.getKey().intValue());
		return keyHolder.getKey().intValue();
	}
	
	@Override
	public int saveEntityReturnKey(Object obj) throws Exception{
		Field[] fields = obj.getClass().getDeclaredFields();
		List objectList = new ArrayList();
		for(Field field: fields){
			if(!field.getName().endsWith("Str") 
					&& !"serialVersionUID".equalsIgnoreCase(field.getName()) 
					&& !TableConstant.TABLE_PRIMARY_KEY.get(
							TableConstant.TABLE_BEAN.get(obj.getClass().getName())
							).equalsIgnoreCase(field.getName())){
				PropertyDescriptor pd = new PropertyDescriptor(field.getName(), obj.getClass());
				Method getMethod = pd.getReadMethod();//获得get方法
				objectList.add(getMethod.invoke(obj));
			}
		}
		return saveEntityReturnKey(createInserSqlStr(obj), objectList.toArray());
	}
	
	@Override
	public boolean saveEntity(Object obj) throws Exception{
		return insert(createInserSqlStr(obj), obj);
	}
	
	private String createInserSqlStr(Object obj) throws Exception{
//		Class c = obj.getClass(); 
		if(StringUtil.isEmpty(TableConstant.TABLE_BEAN.get(obj.getClass().getName()))
				|| StringUtil.isEmpty(TableConstant.TABLE_PRIMARY_KEY.get(TableConstant.TABLE_BEAN.get(obj.getClass().getName())))){
			throw new RuntimeException("请将要操作的数据库表维护到TableConstant类中！");
		}
		String sqlStr = "";
		String[] fieldArr = ObjectUtil.getEntityFiled(obj.getClass());
		StringBuilder sb = new StringBuilder(" insert into ");
		sb.append(TableConstant.TABLE_BEAN.get(obj.getClass().getName()));
		sb.append(" ( ");
		for(String field : fieldArr){
			sb.append(field).append(",");
		}
		sqlStr = sb.toString();
		sqlStr = sqlStr.substring(0, sqlStr.length() - 1);
		sb = new StringBuilder(sqlStr);
		sb.append(" ) values ( ");
		for(int i=0;i clazz = entity.getClass();   
		String tableName = TableConstant.TABLE_BEAN.get(clazz.getName());
		String primaryKey = TableConstant.TABLE_PRIMARY_KEY.get(tableName);
		if(StringUtil.isEmpty(tableName)){
			logger.error("对象实体bean未与数据库表名称映射，请维护TableConstant.java");
			throw new Exception("对象实体bean未与数据库表名称映射，请维护TableConstant.java");
		}
		if(StringUtil.isEmpty(primaryKey)){
			logger.error("数据库表名称未与表主键字段映射，请维护TableConstant.java");
			throw new Exception("数据库表名称未与表主键字段映射，请维护TableConstant.java");
		}
		return updateEntityString(clazz, tableName, primaryKey, entity, updateFields);
    }
	
	private boolean updateEntityString (Class clazz, String tableName, String primaryKey, Object entity, String ... updateFields) throws Exception{
		boolean updateFlag = true;
		StringBuilder sqlBuilder = new StringBuilder("update ").append(tableName);
		sqlBuilder.append(" set ");
		for(int i=0; i objList = new ArrayList();
		for(String field:updateFields){
			//需要利用反射机制，将对象的值取出放到objList中
		    PropertyDescriptor pd = new PropertyDescriptor(field, clazz);   
	        Method getMethod = pd.getReadMethod();  //获得get方法   
			objList.add(getMethod.invoke(entity));
		}
		sqlBuilder.append(" where ");
		sqlBuilder.append(primaryKey).append(" = ? ");   //获得表的主键字段名称
		PropertyDescriptor pd = new PropertyDescriptor(primaryKey, clazz);   
        Method getMethod = pd.getReadMethod();  //获得get方法   
		objList.add(getMethod.invoke(entity));
		try{
			int returnFlag = jdbcTemplate.update(sqlBuilder.toString(), objList.toArray());
			logger.info("returnFlag updateEntityString :" + returnFlag);
		}catch(DataAccessException e){
			logger.error("GeneralDao updateEntityString has failed!" + e);
			updateFlag = false;
		}
        return updateFlag;
	}
	
	private boolean insert(String sql,Object obj){
		boolean updateFlag = true;
		try {
			Field[] fields = obj.getClass().getDeclaredFields();
			List objectList = new ArrayList();
			for(Field field: fields){
				if(!field.getName().endsWith("Str") 
						&& !"serialVersionUID".equalsIgnoreCase(field.getName()) 
						&& !TableConstant.TABLE_PRIMARY_KEY.get(
								TableConstant.TABLE_BEAN.get(obj.getClass().getName())
								).equalsIgnoreCase(field.getName())){
					PropertyDescriptor pd = new PropertyDescriptor(field.getName(), obj.getClass());
					Method getMethod = pd.getReadMethod();//获得get方法
					objectList.add(getMethod.invoke(obj));
				}
			}
			PreparedStatementSetter pss = new ArgumentPreparedStatementSetter(objectList.toArray());
			int returnFlag = jdbcTemplate.update(sql, pss);
			logger.info("returnFlag打印输出：" + returnFlag);
		} catch (Exception e) {
			logger.error("GeneralDao insert has failed!" + e);
			throw new DaoException("数据库操作失败！",e);
		}
		return updateFlag;
	}
	
	@Override
	public int[] batchUpdate(String sql, List batchArgs){
		return jdbcTemplate.batchUpdate(sql, batchArgs);
	}


}
 
  
以上是文章管理的大体实现，其它模块类同。
 
  
项目源码地址：http://www.zyshare.cn/resource/detail/2
 
  
qq群技术交流与支持：557911445
 
  
 
 
  
关注微信公众号“虾米聊吧”，后续持续放送“技术架构和资料”干货！！！  
 
  
 
    
    
 
      
 一个热衷于分享技术和生活的程序猿，让我们一起交流吧~      
 
                    
 
                  微信扫描二维码，关注我的公众号
 		 
    
 
    
  
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                                
  • web前段跨域nginx代理配置
                                    刘正强
nginxcmsWeb
                                    
    nginx代理配置可参考server部分 
 
server { 
        listen       80; 
        server_name  localhost; 
 

    
                                
    • 
                                
  • spring学习笔记
                                    caoyong
spring
                                    
    一、概述 
    a>、核心技术 : IOC与AOP 
 b>、开发为什么需要面向接口而不是实现 
     接口降低一个组件与整个系统的藕合程度，当该组件不满足系统需求时，可以很容易的将该组件从系统中替换掉，而不会对整个系统产生大的影响 
 c>、面向接口编口编程的难点在于如何对接口进行初始化,(使用工厂设计模式) 
    
                                
    • 
                                
  • Eclipse打开workspace提示工作空间不可用
                                    0624chenhong
eclipse
                                    
    做项目的时候，难免会用到整个团队的代码，或者上一任同事创建的workspace， 
1.电脑切换账号后，Eclipse打开时，会提示Eclipse对应的目录锁定，无法访问，根据提示，找到对应目录，G:\eclipse\configuration\org.eclipse.osgi\.manager，其中文件.fileTableLock提示被锁定。 
解决办法，删掉.fileTableLock文件，重
    
                                
    • 
                                
  • Javascript 面向对面写法的必要性？
                                    一炮送你回车库
JavaScript
                                    
    现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember 
这是javascript层的mvc框架哦,不是j2ee的mvc框架 
  
我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用fu
    
                                
    • 
                                
  • js array对象的迭代方法
                                    换个号韩国红果果
array
                                    
    1.forEach 该方法接受一个函数作为参数， 对数组中的每个元素 
使用该函数  return 语句失效 
 

function square(num) {
print(num, num * num);
}
var nums = [1,2,3,4,5,6,7,8,9,10];
nums.forEach(square);
 
2.every 该方法接受一个返回值为布尔类型
    
                                
    • 
                                
  • 对Hibernate缓存机制的理解
                                    归来朝歌
session一级缓存对象持久化
                                    
    在hibernate中session一级缓存机制中，有这么一种情况： 
问题描述：我需要new一个对象，对它的几个字段赋值，但是有一些属性并没有进行赋值，然后调用 
session.save()方法，在提交事务后，会出现这样的情况： 
1：在数据库中有默认属性的字段的值为空 
2：既然是持久化对象，为什么在最后对象拿不到默认属性的值？ 
通过调试后解决方案如下： 
对于问题一，如你在数据库里设置了
    
                                
    • 
                                
  • WebService调用错误合集
                                    darkranger
webservice
                                    
     Java.Lang.NoClassDefFoundError: Org/Apache/Commons/Discovery/Tools/DiscoverSingleton   
调用接口出错， 
一个简单的WebService 
import org.apache.axis.client.Call;import org.apache.axis.client.Service; 
首先必不可
    
                                
    • 
                                
  • JSP和Servlet的中文乱码处理
                                    aijuans
Java Web
                                    
    JSP和Servlet的中文乱码处理 
前几天学习了JSP和Servlet中有关中文乱码的一些问题，写成了博客，今天进行更新一下。应该是可以解决日常的乱码问题了。现在作以下总结希望对需要的人有所帮助。我也是刚学，所以有不足之处希望谅解。 
一、表单提交时出现乱码： 
在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以
    
                                
    • 
                                
  • 面试经典六问
                                    atongyeye
工作面试
                                    
    题记：因为我不善沟通，所以在面试中经常碰壁，看了网上太多面试宝典，基本上不太靠谱。只好自己总结，并试着根据最近工作情况完成个人答案。以备不时之需。 
 
以下是人事了解应聘者情况的最典型的六个问题： 
 
 
1 简单自我介绍  
 
关于这个问题，主要为了弄清两件事，一是了解应聘者的背景，二是应聘者将这些背景信息组织成合适语言的能力。 
 
我的回答：(针对技术面试回答，如果是人事面试，可以就掌
    
                                
    • 
                                
  • contentResolver.query()参数详解
                                    百合不是茶
androidquery()详解
                                    
    收藏csdn的博客,介绍的比较详细,新手值得一看 1.获取联系人姓名 
一个简单的例子，这个函数获取设备上所有的联系人ID和联系人NAME。    
[java]  
view plain 
copy       
 
 public void fetchAllContacts() {   
    
    
                                
    • 
                                
  • ora-00054:resource busy and acquire with nowait specified解决方法
                                    bijian1013
oracle数据库killnowait
                                    
            当某个数据库用户在数据库中插入、更新、删除一个表的数据，或者增加一个表的主键时或者表的索引时，常常会出现ora-00054:resource busy and acquire with nowait specified这样的错误。主要是因为有事务正在执行（或者事务已经被锁），所有导致执行不成功。 
1.下面的语句
    
                                
    • 
                                
  • web 开发乱码
                                    征客丶
springWeb
                                    
    以下前端都是 utf-8 字符集编码 
 
一、后台接收 
1.1、 get 请求乱码 
get 请求中，请求参数在请求头中； 
乱码解决方法： 
a、通过在web 服务器中配置编码格式：tomcat 中，在 Connector 中添加URIEncoding="UTF-8"； 
 
1.2、post 请求乱码 
post 请求中，请求参数分两部份， 
1.2.1、url？参数，
    
                                
    • 
                                
  • 【Spark十六】： Spark SQL第二部分数据源和注册表的几种方式
                                    bit1129
spark
                                    
    Spark SQL数据源和表的Schema 
 
  case class  
  apply schema  
  parquet  
  json  
 JSON数据源 准备源数据 
{"name":"Jack", "age": 12, "addr":{"city":"beijing&
    
                                
    • 
                                
  • JVM学习之:调优总结 -Xms -Xmx -Xmn -Xss
                                    BlueSkator
-Xss-Xmn-Xms-Xmx
                                    
      
堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： 
 
 java -Xmx355
    
                                
    • 
                                
  • jqGrid 各种参数 详解(转帖)
                                    BreakingBad
jqGrid
                                    
      
jqGrid 各种参数 详解   分类： 
源代码分享 
个人随笔请勿参考 
解决开发问题 2012-05-09 20:29   84282人阅读   
评论(22)   
收藏   
举报   
jquery 
服务器 
parameters 
function 
ajax 
string      
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-代理模式-Proxy
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/*
 * 下面
    
                                
    • 
                                
  • 应用升级iOS8中遇到的一些问题
                                    chenhbc
ios8升级iOS8
                                    
    1、很奇怪的问题，登录界面，有一个判断，如果不存在某个值，则跳转到设置界面，ios8之前的系统都可以正常跳转，iOS8中代码已经执行到下一个界面了，但界面并没有跳转过去，而且这个值如果设置过的话，也是可以正常跳转过去的，这个问题纠结了两天多，之前的判断我是在 
-(void)viewWillAppear:(BOOL)animated 
 中写的，最终的解决办法是把判断写在 
-(void
    
                                
    • 
                                
  • 工作流与自组织的关系？
                                    comsci
设计模式工作
                                    
      目前的工作流系统中的节点及其相互之间的连接是事先根据管理的实际需要而绘制好的，这种固定的模式在实际的运用中会受到很多限制，特别是节点之间的依存关系是固定的，节点的处理不考虑到流程整体的运行情况，细节和整体间的关系是脱节的，那么我们提出一个新的观点，一个流程是否可以通过节点的自组织运动来自动生成呢？这种流程有什么实际意义呢？ 
 
  这里有篇论文，摘要是：“针对网格中的服务
    
                                
    • 
                                
  • Oracle11.2新特性之INSERT提示IGNORE_ROW_ON_DUPKEY_INDEX
                                    daizj
oracle
                                    
    insert提示IGNORE_ROW_ON_DUPKEY_INDEX 
 
转自：http://space.itpub.net/18922393/viewspace-752123 
 
在 insert into tablea ...select * from tableb中，如果存在唯一约束，会导致整个insert操作失败。使用IGNORE_ROW_ON_DUPKEY_INDEX提示，会忽略唯一
    
                                
    • 
                                
  • 二叉树:堆
                                    dieslrae
二叉树
                                    
        这里说的堆其实是一个完全二叉树,每个节点都不小于自己的子节点,不要跟jvm的堆搞混了.由于是完全二叉树,可以用数组来构建.用数组构建树的规则很简单: 
    一个节点的父节点下标为: (当前下标 - 1)/2 
    一个节点的左节点下标为: 当前下标 * 2 + 1 
  &
    
                                
    • 
                                
  • C语言学习八结构体
                                    dcj3sjt126com
c
                                    
    为什么需要结构体，看代码 
# include <stdio.h>

struct Student	//定义一个学生类型，里面有age, score, sex, 然后可以定义这个类型的变量
{
	int age;
	float score;
	char sex;
}

int main(void)
{
	struct Student st = {80, 66.6,
    
                                
    • 
                                
  • centos安装golang
                                    dcj3sjt126com
centos
                                    
    #在国内镜像下载二进制包 
wget -c  http://www.golangtc.com/static/go/go1.4.1.linux-amd64.tar.gz 
tar -C /usr/local -xzf go1.4.1.linux-amd64.tar.gz 
  
#把golang的bin目录加入全局环境变量 
cat >>/etc/profile<
    
                                
    • 
                                
  • 10.性能优化-监控-MySQL慢查询
                                    frank1234
性能优化MySQL慢查询
                                    
    1.记录慢查询配置 
show variables where variable_name like 'slow%' ; --查看默认日志路径 
查询结果：--不用的机器可能不同 
slow_query_log_file=/var/lib/mysql/centos-slow.log 
 
修改mysqld配置文件：/usr /my.cnf[一般在/etc/my.cnf，本机在/user/my.cn
    
                                
    • 
                                
  • Java父类取得子类类名
                                    happyqing
javathis父类子类类名
                                    
      
在继承关系中，不管父类还是子类，这些类里面的this都代表了最终new出来的那个类的实例对象，所以在父类中你可以用this获取到子类的信息！ 
  
package com.urthinker.module.test;

import org.junit.Test;

abstract class BaseDao<T> {
	public void 
    
                                
    • 
                                
  • Spring3.2新注解@ControllerAdvice
                                    jinnianshilongnian
@Controller
                                    
    @ControllerAdvice，是spring3.2提供的新注解，从名字上可以看出大体意思是控制器增强。让我们先看看@ControllerAdvice的实现： 
  
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Co
    
                                
    • 
                                
  • Java spring mvc多数据源配置
                                    liuxihope
spring
                                    
    转自：http://www.itpub.net/thread-1906608-1-1.html 
 
 
1、首先配置两个数据库 
 
<bean id="dataSourceA"         class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close&quo
    
                                
    • 
                                
  • 第12章 Ajax（下）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • BW / Universe Mappings
                                    blueoxygen
BO
                                    
          
BW Element    
OLAP Universe Element      
Cube  Dimension    
Class      
Charateristic    
A class with dimension and detail objects (Detail objects for key and desription)      
Hi
    
                                
    • 
                                
  • Java开发熟手该当心的11个错误
                                    tomcat_oracle
java多线程工作单元测试
                                    
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
    
                                
    • 
                                
  • 推行国产操作系统的优劣
                                    yananay
windowslinux国产操作系统
                                    
    最近刮起了一股风，就是去“国外货”。从应用程序开始，到基础的系统，数据库，现在已经刮到操作系统了。原因就是“棱镜计划”，使我们终于认识到了国外货的危害，开始重视起了信息安全。操作系统是计算机的灵魂。既然是灵魂，为了信息安全，那我们就自然要使用和推行国货。可是，一味地推行，是否就一定正确呢？ 
 
先说说信息安全。其实从很早以来大家就在讨论信息安全。很多年以前，就据传某世界级的网络设备制造商生产的交
    
                                
    •