不会编程的小菜
不会编程的小菜

spring boot 官方文档翻译之 集成 dubbo zookeeper

spring boot 官方文档翻译之 集成 dubbo zookeeper_第1张图片

以上是项目接口图，由于dubbo 官方要求接口要生产端和消费端共享，所以接口暂时放在common包下面，然后model装所有的entity,因为service 和 controller工程都要公用model，先来项目结构图

 

model 模块 

spring boot 官方文档翻译之 集成 dubbo zookeeper_第2张图片

 

model代码

 

 

package com.book.model.file;

import java.util.Date;

import com.book.model.obj.AbstractObject;




/**
 * 【】持久化对象 数据库表：tb_file_store
 * 
 * @date 2017-03-25 17:55:49
 * 
 */
public class FileStore extends AbstractObject{

    public static final long serialVersionUID = 1L;

    // 主键
    private String fileId;
    // 
    private String groupId;
    // 
    private String filePath;
    // 
    private String fileName;
    // 
    private String fileExtName;
    // 
    private Integer fileSize;
    // 
    private Date createDate;
    // 
    private String createUser;
    // 
    private Date lastUpdateDate;
    // 
    private String lastUpdateUser;
    // 
    private Integer deleteFlag;

    /** 获取 主键 属性 */
    public String getFileId() {
        return fileId;
    }

    /** 设置 主键 属性 */
    public void setFileId(String fileId) {
        this.fileId = fileId;
    }

    /** 获取  属性 */
    public String getGroupId() {
        return groupId;
    }

    /** 设置  属性 */
    public void setGroupId(String groupId) {
        this.groupId = groupId;
    }

    /** 获取  属性 */
    public String getFilePath() {
        return filePath;
    }

    /** 设置  属性 */
    public void setFilePath(String filePath) {
        this.filePath = filePath;
    }

    /** 获取  属性 */
    public String getFileName() {
        return fileName;
    }

    /** 设置  属性 */
    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    /** 获取  属性 */
    public String getFileExtName() {
        return fileExtName;
    }

    /** 设置  属性 */
    public void setFileExtName(String fileExtName) {
        this.fileExtName = fileExtName;
    }

    /** 获取  属性 */
    public Integer getFileSize() {
        return fileSize;
    }

    /** 设置  属性 */
    public void setFileSize(Integer fileSize) {
        this.fileSize = fileSize;
    }

    /** 获取  属性 */
    public Date getCreateDate() {
        return createDate;
    }

    /** 设置  属性 */
    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    /** 获取  属性 */
    public String getCreateUser() {
        return createUser;
    }

    /** 设置  属性 */
    public void setCreateUser(String createUser) {
        this.createUser = createUser;
    }

    /** 获取  属性 */
    public Date getLastUpdateDate() {
        return lastUpdateDate;
    }

    /** 设置  属性 */
    public void setLastUpdateDate(Date lastUpdateDate) {
        this.lastUpdateDate = lastUpdateDate;
    }

    /** 获取  属性 */
    public String getLastUpdateUser() {
        return lastUpdateUser;
    }

    /** 设置  属性 */
    public void setLastUpdateUser(String lastUpdateUser) {
        this.lastUpdateUser = lastUpdateUser;
    }

    /** 获取  属性 */
    public Integer getDeleteFlag() {
        return deleteFlag;
    }

    /** 设置  属性 */
    public void setDeleteFlag(Integer deleteFlag) {
        this.deleteFlag = deleteFlag;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append("FileStore");
        sb.append("{fileId=").append(fileId);
        sb.append(", groupId=").append(groupId);
        sb.append(", filePath=").append(filePath);
        sb.append(", fileName=").append(fileName);
        sb.append(", fileExtName=").append(fileExtName);
        sb.append(", fileSize=").append(fileSize);
        sb.append(", createDate=").append(createDate);
        sb.append(", createUser=").append(createUser);
        sb.append(", lastUpdateDate=").append(lastUpdateDate);
        sb.append(", lastUpdateUser=").append(lastUpdateUser);
        sb.append(", deleteFlag=").append(deleteFlag);
        sb.append('}');
        return sb.toString();
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof FileStore) {
            FileStore fileStore = (FileStore) obj;
            if (this.getFileId().equals(fileStore.getFileId())) {
                return true;
            }
        }
        return false;
    }

    public int hashCode() {
        String pkStr = "" + this.getFileId();
        return pkStr.hashCode();
    }

}

 

 

 

 

 

 

 package com.book.model.obj;
 
import java.io.Serializable;

import org.apache.commons.lang.builder.ToStringBuilder;
 
 public abstract class AbstractObject
   implements Serializable, Cloneable
 {
   public static final long serialVersionUID = 1L;
 
   public String toString()
   {
     return ToStringBuilder.reflectionToString(this);
   }
 
   public Object clone()
   {
     Object obj = null;
     try {
       obj = super.clone();
     } catch (CloneNotSupportedException e) {
       e.printStackTrace();
     }
     return obj;
   }
 }

 

package com.book.model;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ModelApplication {

	public static void main(String[] args) {
		SpringApplication.run(ModelApplication.class, args);
	}
}

model模块的 pom文件

 

 



	4.0.0

	com.book
	model
	0.0.1-SNAPSHOT
	jar

	model
	Demo project for Spring Boot

	
		org.springframework.boot
		spring-boot-starter-parent
		1.5.3.RELEASE
		 
	

	
		UTF-8
		UTF-8
		1.8
		2.6
	

	
		
			org.springframework.boot
			spring-boot-starter
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		
		
		
				
		
		    commons-lang
		    commons-lang
		    ${commonslang.version}
		
		
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin

 

 

 

 

 


common模块 ，主要是做一些底层公共方法的封装，以及接口的暴露

spring boot 官方文档翻译之 集成 dubbo zookeeper_第3张图片

 

 

从上到下的顺序 

 

package com.book.common.base.constant;

/**
 * 常量类
 * @author Administrator
 *
 */
public class BaseConstant {

    /** 通用状态 -- 启用 */
    public static final int STATUS_ENABLED = 1;
    /** 通用状态 -- 禁用 */
    public static final int STATUS_DISABELD = 0;

    /** 返回状态--成功 */
    public static final int STATUS_SUCCESS = 0;

    /** 返回状态--失败 */
    public static final int STATUS_FAILURE = 1;

	public static int getStatusEnabled() {
		return STATUS_ENABLED;
	}

	public static int getStatusDisabeld() {
		return STATUS_DISABELD;
	}

	public static int getStatusSuccess() {
		return STATUS_SUCCESS;
	}

	public static int getStatusFailure() {
		return STATUS_FAILURE;
	}
}

 

package com.book.common.base.dao;

import java.util.List;
import java.util.Map;

public abstract interface MyBatisBaseDao
{
  public abstract 
 int insert(P paramP);

  public abstract 
 int update(P paramP);

  public abstract 
 int delete(P paramP);

  public abstract  T selectObject(P paramP);

  public abstract  List selectObjectList(P paramP);

  public abstract  Map selectMap(P paramP);

  public abstract  List> selectMapList(P paramP);

  public abstract  List page(P paramP);

  public abstract 
 int pageCount(P paramP);
}

 

package com.book.common.base.page;
 
import java.util.Collection;

import com.book.model.obj.AbstractObject;


 
 public class Page extends AbstractObject
 {
   private int page;
   private int pageSize;
   private long count;
   public Collection data;
 
   public Page(int pageIndex, int pageSize, long rowCount, Collection data)
   {
     this.page = pageIndex;
     this.pageSize = pageSize;
     this.count = rowCount;
     this.data = data;
   }
 
   public int getPage() {
     return this.page;
   }
 
   public void setPage(int page) {
     this.page = page;
   }
 
   public int getPageSize() {
     return this.pageSize;
   }
 
   public void setPageSize(int pageSize) {
     this.pageSize = pageSize;
   }
 
   public long getCount() {
     return this.count;
   }
 
   public void setCount(long count) {
     this.count = count;
   }
 
   public Collection getData() {
     return this.data;
   }
 
   public void setData(Collection data) {
     this.data = data;
   }
 }

 

package com.book.common.base.service;

import java.util.List;
import java.util.Map;

import com.book.common.base.page.Page;



public abstract interface MybatisBaseService
{
  public abstract 
 int insert(P paramP);

  public abstract 
 int update(P paramP);

  public abstract 
 int delete(P paramP);

  public abstract  T selectObject(P paramP);

  public abstract  List selectObjectList(P paramP);

  public abstract  Map selectMap(P paramP);

  public abstract  List> selectMapList(P paramP);

  public abstract  Page page(Map paramMap, int paramInt1, int paramInt2);

  public abstract  Page page(String paramString1, String paramString2, Map paramMap, int paramInt1, int paramInt2);
}

 

 package com.book.common.base.service.impl;
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.book.common.base.dao.MyBatisBaseDao;
import com.book.common.base.page.Page;
import com.book.common.base.service.MybatisBaseService;




 
 public abstract class MybatisBaseServiceImpl implements MybatisBaseService
 {
   private static final Logger LOGGER = LoggerFactory.getLogger(MybatisBaseServiceImpl.class);
 
   public static int type = 1;
   public static final int MYSQL = 1;
   public static final int ORACLE = 2;
 
   public abstract MyBatisBaseDao getDao();
 
   public  int insert(T parameter)
   {
     return getDao().insert(parameter);
   }
 
   public  int update(T parameter)
   {
     return getDao().update(parameter);
   }
 
   public  int delete(T parameter)
   {
     return getDao().delete(parameter);
   }
 
   public  T selectObject(P parameter)
   {
     return getDao().selectObject(parameter);
   }
 
   public  List selectObjectList(P parameter)
   {
     return getDao().selectObjectList(parameter);
   }
 
   public  Map selectMap(P parameter)
   {
     return getDao().selectMap(parameter);
   }
 
   public  List> selectMapList(P parameter)
   {
     return getDao().selectMapList(parameter);
   }
 
   public  Page page(Map map, int pageIndex, int pageSize)
   {
     int count = getDao().pageCount(map);
 
     int offset = (pageIndex - 1) * pageSize;
 
     if (type == 1) {
       map.put("offset", Integer.valueOf(offset));
       map.put("rows", Integer.valueOf(pageSize));
     } else if (type == 2) {
       map.put("begin", Integer.valueOf(offset));
       map.put("end", Integer.valueOf(offset + pageSize));
     }
 
     List list = getDao().page(map);
 
     return new Page(pageIndex, pageSize, count, list);
   }
 
   public  Page page(String pageSelectId, String pageCountSelectId, Map map, int pageIndex, int pageSize)
   {
     MyBatisBaseDao dao = getDao();
 
     int count = 0;
 
     Class clazz = dao.getClass();
     Method method = null;
     try {
       method = clazz.getDeclaredMethod(pageCountSelectId, new Class[] { Map.class });
     } catch (NoSuchMethodException e1) {
       LOGGER.error("分页查询【记录数】异常，请检查【{}.{}(Map map)】方法是否存在!", new Object[] { dao.getClass().getName(), pageCountSelectId });
     }
     catch (SecurityException e1) {
       e1.printStackTrace();
     }
     try
     {
       try {
         count = ((Integer)method.invoke(dao, new Object[] { map })).intValue();
       } catch (ClassCastException e) {
         LOGGER.error("分页查询【记录数】异常，【{}.{}(Map map)】方法的返回值不是int类型!", new Object[] { dao.getClass().getName(), pageCountSelectId });
       }
     } catch (IllegalAccessException e1) {
       e1.printStackTrace();
     } catch (IllegalArgumentException e1) {
       e1.printStackTrace();
     } catch (InvocationTargetException e1) {
       LOGGER.error("分页查询【记录数】异常，请检查Mapper.xml文件中是否有对应 select id 【{}】!", new Object[] { pageCountSelectId });
     }
 
     int offset = (pageIndex - 1) * pageSize;
 
     if (type == 1) {
       map.put("offset", Integer.valueOf(offset));
       map.put("rows", Integer.valueOf(pageSize));
     } else if (type == 2) {
       map.put("begin", Integer.valueOf(offset));
       map.put("end", Integer.valueOf(offset + pageSize));
     }
 
     List list = null;
 
     Class clazz2 = dao.getClass();
     Method method2 = null;
     try {
       method2 = clazz2.getDeclaredMethod(pageSelectId, new Class[] { Map.class });
     } catch (NoSuchMethodException e) {
       LOGGER.error("分页查询【记录数】异常，请检查【{}.{}(Map map)】方法是否存在!", new Object[] { dao.getClass().getName(), pageSelectId });
     }
     catch (SecurityException e) {
       e.printStackTrace();
     }
     try
     {
       try {
         list = (ArrayList)method2.invoke(dao, new Object[] { map });
       } catch (ClassCastException e) {
         LOGGER.error("分页查询【记录数】异常，【{}.{}(Map map)】方法的返回值不是List类型!", new Object[] { dao.getClass().getName(), pageSelectId });
       }
     } catch (IllegalAccessException e) {
       e.printStackTrace();
     } catch (IllegalArgumentException e) {
       e.printStackTrace();
     } catch (InvocationTargetException e) {
       LOGGER.error("分页查询【数据集】异常，请检查Mapper.xml文件中是否有对应 select id 【{}】!", new Object[] { pageSelectId });
     }
 
     return new Page(pageIndex, pageSize, count, list);
   }
   
   public String dbThreadName()
   {
     String threadName = "DB_" + getClass().getSimpleName().replace("ServiceImpl", "").toUpperCase() + "_THREAD";
     return threadName;
   }
 }

 

package com.book.common.base.to;

import com.book.common.base.constant.BaseConstant;

/**
*  
* @Description: TODO  结果统一返回
* @date 2017年6月4日
* @author haoran
 */
public class ResultTO {

    private static final long serialVersionUID = 1L;
    //返回状态  0成功  1失败 2token过期，状态统一使用BaseConstant里面的STATUS_SUCCESS、STATUS_FAILURE和STATUS_TOKEN_INVALID
    private int status;
    //附加消息
    private String msg;
    //数据体
    private Object data;

    public ResultTO() {

    }

    private ResultTO(int status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }
    
    /**
     * 成功，且无特殊附加消息时使用
     * @param data
     * @return
     * @return ResultTO
     */
    public static ResultTO newSuccessResultTO(Object data) {
        return ResultTO.newSuccessResultTO("success", data);
    }
    /**
     * 失败，且无特殊附加消息时使用
     * @param data
     * @return
     * @return ResultTO
     */
    public static ResultTO newFailResultTO(Object data) {
        return ResultTO.newSuccessResultTO("failure", data);
    }

    /**
     * 成功 时候使用
     * @param msg
     * @param data
     * @return
     * @return ResultTO
     */
    public static ResultTO newSuccessResultTO(String msg, Object data) {
        return new ResultTO(BaseConstant.STATUS_SUCCESS, msg, data);
    }
    /**
     * 失败时候使用
     * @param msg
     * @param data
     * @return
     * @return ResultTO
     */
    public static ResultTO newFailResultTO(String msg, Object data) {
        return new ResultTO(BaseConstant.STATUS_FAILURE, msg, data);
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String error) {
        this.msg = error;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

}

 

package com.book.common.dao.file;

import com.book.common.base.dao.MyBatisBaseDao;

public interface FileStoreDao extends MyBatisBaseDao{
	
}

 

package com.book.common.service.file;

import com.book.common.base.service.MybatisBaseService;

/**
 * 【】 服务类 接口
 * 
 * @date 2017-03-25 14:24:55
 * 
 */
public interface FileStoreService extends MybatisBaseService {
	
}

 

package com.book.common;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class CommonApplication {

	public static void main(String[] args) {
		SpringApplication.run(CommonApplication.class, args);
	}
}


common的 pom文件

 

 



	4.0.0

	com.book
	common
	0.0.1-SNAPSHOT
	jar

	common
	Demo project for Spring Boot

	
		org.springframework.boot
		spring-boot-starter-parent
		1.5.3.RELEASE
		 
	

	
		UTF-8
		UTF-8
		1.8
	

	
		
		
		
			com.book
			model
			0.0.1-SNAPSHOT
		
	
		
			org.springframework.boot
			spring-boot-starter
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin


service 模块的目录图

 

spring boot 官方文档翻译之 集成 dubbo zookeeper_第4张图片

 

service 代码

 

 

package com.book.server.config;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import com.alibaba.druid.pool.DruidDataSource;

@Configuration
@MapperScan("com.book.common.dao.*")
@ImportResource("classpath:spring/spring-tx.xml")
public class DataSourceConfiguration {
  private static final Logger LOGGER = LoggerFactory.getLogger(DataSourceConfiguration.class);
  	
  @Bean
  public SqlSessionFactory sqlSessionFactoryBean() throws Exception {
	  SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
	  sqlSessionFactoryBean.setDataSource(dataSource());
	  PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
	  sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:/mybatis/mapper/*/*.xml"));
	  LOGGER.info("数据库初始化完成");
	  return sqlSessionFactoryBean.getObject();
  }

  @Bean
  @ConfigurationProperties(prefix = "spring.datasource")
  public DataSource dataSource() {
    return new DruidDataSource();
  }
  
  
  @Bean(name="transactionManager")
  public DataSourceTransactionManager transactionManager() {
	  LOGGER.info("切入事务完成");
      return new DataSourceTransactionManager(dataSource());
  }
  
  
}

 

package com.book.server.config;


import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

import com.alibaba.dubbo.rpc.Exporter;

@Configuration
@ConditionalOnClass(Exporter.class)
@ImportResource("classpath:dubbo/dubbo-provider.xml")
public class DubboConfiguration {

	
}

 

package com.book.server.service.impl.file;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.book.common.base.dao.MyBatisBaseDao;
import com.book.common.base.service.impl.MybatisBaseServiceImpl;
import com.book.common.dao.file.FileStoreDao;
import com.book.common.service.file.FileStoreService;





/**
 * 【】 服务类 实现类
 * 
 * @date 2017-03-25 14:24:55
 * 
 */
@Service(value = "fileStoreService")
public class FileStoreServiceImpl extends MybatisBaseServiceImpl implements FileStoreService {

    private static final Logger LOGGER = LoggerFactory.getLogger(FileStoreServiceImpl.class);

    @Autowired
    private FileStoreDao fileStoreDao;

    @Override
    public MyBatisBaseDao getDao() {
        return fileStoreDao;
    }
}

 

package com.book.server;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.book.common.service.file.FileStoreService;

@RestController  
@SpringBootApplication 
public class ServiceApplication {
	
	@Autowired
	private  FileStoreService  fileStoreService;
	
	
	 @RequestMapping("/")  
	   List home() {  
		Map map=new HashMap();
		map.put("fileId", 2);
	    return fileStoreService.selectObjectList(map);  
	    }  
	
	
	public static void main(String[] args) {
		SpringApplication.run(ServiceApplication.class, args);
	}
}
 
  
 
 
  
配置文件目录结构
 
  
spring boot 官方文档翻译之 集成 dubbo zookeeper_第5张图片
 
  
 
 
  



	
        
    
    
    
    

    
   
    
  	
    

 
  
 
 
  






	
		
       
       
       
       
       
       
       
       
       
       
	
	
	
	
	
	
	   insert into tb_file_store (
	     file_id,
	     group_id,
	     file_path,
	     file_name,
	     file_ext_name,
	     file_size,
	     create_date,
	     create_user,
	     last_update_date,
	     last_update_user,
	     delete_flag
	   )values (
	     #{fileId},
	     #{groupId},
	     #{filePath},
	     #{fileName},
	     #{fileExtName},
	     #{fileSize},
	     #{createDate},
	     #{createUser},
	     #{lastUpdateDate},
	     #{lastUpdateUser},
	     #{deleteFlag}
	   )
	

	
		update tb_file_store
		
			
				file_id=#{fileId},
			
			
				group_id=#{groupId},
			
			
				file_path=#{filePath},
			
			
				file_name=#{fileName},
			
			
				file_ext_name=#{fileExtName},
			
			
				file_size=#{fileSize},
			
			
				create_date=#{createDate},
			
			
				create_user=#{createUser},
			
			
				last_update_date=#{lastUpdateDate},
			
			
				last_update_user=#{lastUpdateUser},
			
			
				delete_flag=#{deleteFlag},
			
		
		
			file_id=#{fileId} 
		
	

	
	   delete from 
	     tb_file_store 
	   where 
	    file_id=#{fileId} 
	

	
	
	

	

	
	
	

	

	
	   from tb_file_store
	   
	     
	        file_id=#{fileId}
	     
	     
	        and group_id=#{groupId}
	     
	     
	        and file_path=#{filePath}
	     
	     
	        and file_name=#{fileName}
	     
	     
	        and file_ext_name=#{fileExtName}
	     
	     
	        and file_size=#{fileSize}
	     
	     
	        and create_date=#{createDate}
	     
	     
	        and create_user=#{createUser}
	     
	     
	        and last_update_date=#{lastUpdateDate}
	     
	     
	        and last_update_user=#{lastUpdateUser}
	     
	     
	        and delete_flag=#{deleteFlag}
	     
	   
	

	
 
 
  

 spring 切面事务
 
  
 
 
  


   
    
    
        
            
            
            
            
            
            
            
            
            
            
            
            
            
        
    
    
    
    
        
        
    
	 

 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
#port
server.port=8080
#datasource
spring.datasource.url=jdbc:MySQL://IP:3306/filedata
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
log配置
 
  
 
 
  
log4j.rootLogger = dubug,console,file

log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Threshold = dubug 
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern = [%-d{yyyy-MM-dd HH:mm:ss}] - [ %p ]  %m%n

log4j.appender.file = org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.File =../logs/service/server.log
log4j.appender.file.Append = true
log4j.appender.file.Threshold = dubug 
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = [%-d{yyyy-MM-dd HH:mm:ss}]-[ %p ] %c  %m%n
 
  

 mybatis-config.xml
 
  
 
 
  
 
 
  



	  
	      
		  
   		  
		  
    	  
  		  
  		  
	  

 
  

 pom.xml
 
  
 
 
  
 
 
  
 
 
  


	4.0.0

	com.book
	service
	0.0.1-SNAPSHOT

	service
	Demo project for Spring Boot

	
		org.springframework.boot
		spring-boot-starter-parent
		1.5.3.RELEASE
		 
	

	
		UTF-8
		UTF-8
		1.8
		2.6
		1.3.8.RELEASE
		3.2.4
        2.5.3
		0.1  
	

	
		
		
			com.book
			common
			0.0.1-SNAPSHOT
		
		
		
		
			org.springframework.boot
			spring-boot-starter-jdbc
		
		
		
			org.mybatis.spring.boot
			mybatis-spring-boot-starter
			1.3.0
		
		
		
		
			org.springframework.boot
			spring-boot-starter-web
			
				
					org.springframework.boot
					spring-boot-starter-logging
				
			
		

		
			org.springframework.boot
			spring-boot-starter-log4j
			${spring.boot.starter.log4j.version}
		
		
		
		
			mysql
			mysql-connector-java
			runtime
		
		
			org.springframework.boot
			spring-boot-starter-test
			test
		
		
		
		  
	      
	      com.alibaba  
	      druid  
	      1.0.15  
	     
		
		
		
		
			org.aspectj
			aspectjweaver
		

		
		
			cglib
			cglib
			${cglib.version}
		
		
		
		
		
			com.alibaba
			dubbo
			${dubbo.version}
			
				
					org.springframework
					spring
				
				
					org.slf4j
					slf4j-api
				
			
		
		
			com.github.sgroschupf
			zkclient
			${zkclient.version}
		 
		
		
		
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin
			
		
	




 
  

 controller模块
 
  
 
 
  
spring boot 官方文档翻译之 集成 dubbo zookeeper_第6张图片
 
  
 
 
  
代码
 
  
 
 
  
package com.book.api.config;


import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

import com.alibaba.dubbo.rpc.Invoker;

@Configuration
@ConditionalOnClass(Invoker.class)
@ImportResource("classpath:dubbo/dubbo-customer.xml")
public class DubboConfiguration {

	
}

 
  
 
 
  
package com.book.api.test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.book.common.base.page.Page;
import com.book.common.base.to.ResultTO;
import com.book.common.service.file.FileStoreService;
import com.book.model.file.FileStore;


/**
*  
* @Description: TODO  测试  rest
* @return ResultTO    返回类型
* @date 2017年6月4日
* @author haoran
 */

@RestController
@RequestMapping("test/*")
public class TestController {

	
		@Autowired
		private  FileStoreService  fileStoreService;
		
		/**
		 * 查询所有
		 * @Description: TODO(这里用一句话描述这个方法的作用)
		 * @return ResultTO    返回类型
		 * @date 2017年6月4日
		 * @author Administrator
		 */
		@RequestMapping(value = "/list",method = RequestMethod.GET)
		public ResultTO list(){
			Map map=new HashMap();
		    List fileStoreList= fileStoreService.selectObjectList(map); 
		    return ResultTO.newSuccessResultTO("成功",fileStoreList);
		}
		
		
		/**
		 * 分页查询列表
		 * @Description: TODO(这里用一句话描述这个方法的作用)
		 * @return ResultTO    返回类型
		 * @date 2017年6月4日
		 * @author Administrator
		 */
		@RequestMapping(value = "/page",method = RequestMethod.GET)
		public ResultTO page(@RequestParam int pageIndex,@RequestParam int pageSize){
			Map map=new HashMap();
			Page fileStoreList= fileStoreService.page(map, pageIndex, pageSize);
		    return ResultTO.newSuccessResultTO("成功",fileStoreList);
		}
		
		
		
		/**
		 * 单条查询
		 * @Description: TODO(这里用一句话描述这个方法的作用)
		 * @return ResultTO    返回类型
		 * @date 2017年6月4日
		 * @author Administrator
		 */
		@RequestMapping(value = "/{fileId}",method = RequestMethod.GET)
		public ResultTO queryById(@PathVariable("fileId")String fileId){
			Map map=new HashMap();
			map.put("fileId", fileId);
			FileStore  fileStore = fileStoreService.selectObject(map);
			return ResultTO.newSuccessResultTO("成功",fileStore);
		}
		
		/**
		 * 添加
		 * @Description: TODO(这里用一句话描述这个方法的作用)
		 * @return ResultTO    返回类型
		 * @date 2017年6月4日
		 * @author Administrator
		 */
		@RequestMapping(value = "/add",method = RequestMethod.POST)
		public ResultTO add(@RequestBody FileStore  fileStore){
			int count=fileStoreService.insert(fileStore);
			if(count>0){
				return ResultTO.newSuccessResultTO("成功");
			}else{
				return ResultTO.newSuccessResultTO("失败");
			}
		}
		
		
		/**
		 * 删除
		 * @Description: TODO(这里用一句话描述这个方法的作用)
		 * @return ResultTO    返回类型
		 * @date 2017年6月4日
		 * @author Administrator
		 */
		@RequestMapping(value = "/{fileId}",method = RequestMethod.DELETE)
		public ResultTO del(@PathVariable("fileId")String fileId){
			int count=fileStoreService.delete(fileId);
			if(count>0){
				return ResultTO.newSuccessResultTO("成功");
			}else{
				return ResultTO.newSuccessResultTO("失败");
			}
		}
	
}

 
  
 
 
  
package com.book.api;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ControllerApplication {
	
	public static void main(String[] args) {
		SpringApplication.run(ControllerApplication.class, args);
	}
}

 
  
 
 
  
 
 
  
消费者配置文件
 
  
 
 
  
  
  
    
      
    
      
    
    
    
    
    
  
 
  

 application.properties
 
  
 
 
  
 
 
  
 
 
  
server.port=8081
 
  
 
 
  
pom.xml依赖
 
  
 
 
  


	4.0.0

	com.book
	controller
	0.0.1-SNAPSHOT
	jar

	controller
	Demo project for Spring Boot

	
		org.springframework.boot
		spring-boot-starter-parent
		1.5.3.RELEASE
		 
	

	
		UTF-8
		UTF-8
		1.8
		2.5.3
		0.1  
	

	
		
		
			com.book
			common
			0.0.1-SNAPSHOT
		
		
		
		
			org.springframework.boot
			spring-boot-starter-web
		
	
		
			org.springframework.boot
			spring-boot-starter
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		
		
		
				
		
			com.alibaba
			dubbo
			${dubbo.version}
			
				
					org.springframework
					spring
				
				
					org.slf4j
					slf4j-api
				
			
		
		
			com.github.sgroschupf
			zkclient
			${zkclient.version}
		 
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin
			
		
	




 
  

 然后是启动项目
 
  
 
 
  
先打包model ，再打包 common,再跑生产端 main方法 ，最后消费端main方法，启动的时候可以上dubbo-admin管理中心查看是否已经注册
 
  
下面是运行截图
 
  
 
  
 
  
项目启动以后 访问生产者端 http://localhost:8081/test/list  可以看到生产者调用消费者接口返回的数据，消费者不依赖于生产者
 
  
spring boot 官方文档翻译之 集成 dubbo zookeeper_第7张图片
 
  
如果不足的地方欢迎修正
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(springboot,dubbo)

        

            

                
    
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        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
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • Dubbo架构概览：服务注册与发现、远程调用、监控与管理
                        木南曌
dubbo架构
                        
    Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
    
                    
    • 
                    
  • java 技术 架构 相关文档
                        圣心
java架构开发语言
                        
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
    
                    
    • 
                    
  • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式
                        花儿街参考

                        
    ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
    
                    
    • 
                    
  • SpringBoot 设置传入参数非必要
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
    
                    
    • 
                    
  • SpringBoot 获取 ApplicationContext
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
    
                    
    • 
                    
  • 关于项目中使用shiro进行安全管理的总结
                        一颗大青柠
JavaShirojavaspring
                        
    关于项目中使用shiro进行安全管理的总结关于SpringBoot下使用shiro进行用户认证与权限管理对于安全框架有一定了解的开发者一定对于shiro这款安全框架有一定的了解，这里我们不再对该框架进行其设计与知识的介绍，仅对于我的个人项目中所使用到的进行一个总结，并放上代码。使用该框架的第一步，进行配置：packagecom.libvirtjava.demo.vm.util.config;imp
    
                    
    • 
                    
  • Spring Boot 请求处理流程：从负载均衡到多实例并发 - 电子商务网站实例
                        烟雨国度
springboot负载均衡后端
                        
    SpringBoot请求处理流程：从负载均衡到多实例并发-电子商务网站实例SpringBoot请求处理流程：从负载均衡到多实例并发SpringBoot作为一个强大的Java应用开发框架，能够有效地处理高并发请求。本文将基于三个关键流程图，详细分析SpringBoot应用如何从负载均衡到请求处理，再到多实例并发处理的整个过程。1.负载均衡和多实例处理首先，让我们看一下描述负载均衡和多实例处理的流程图
    
                    
    • 
                    
  • 微服务架构 | nacos - [自动刷新配置方式 & 失效排查]
                        问仙长何方蓬莱
微服务java技术SpringCloud微服务javanacos
                        
    INDEX§1配置方式§1.1springboot配置§1.2springcloud配置§2失效排查§2.1常见失效场景§2.1.1配置不配套§2.1.2自动刷新未开启§2.1.3依赖冲突§2.1.4改错了配置文件§2.2未知情况关键排查点§1配置方式nacos的配置中心主要有两套配置方式，配置方式不互相共通，需要配套配置springbootspringcloud§1.1springboot配置依
    
                    
    • 
                    
  • 【免费】springboot项目申报管理系统|毕业设计|Javaweb项目
                        计算机学姐来啦
springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee
                        
    收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
    
                    
    • 
                    
  • springboot与日志
                        最后的夏t

                        
    日志1、日志框架小张；开发一个大型系统；1、System.out.println("")；将关键数据打印在控制台；去掉？写在一个文件？2、框架来记录系统的一些运行时信息；日志框架；zhanglogging.jar；3、高大上的几个功能？异步模式？自动归档？xxxx？zhanglogging-good.jar？4、将以前框架卸下来？换上新的框架，重新修改之前相关的API；zhanglogging-p
    
                    
    • 
                    
  • 计算机信息管理本科自考选题推荐
                        李哥讲程序开发
javaspringboot开发语言
                        
    计算机信息管理专业是一个跨学科的领域，它结合了计算机技术与管理技术，旨在利用计算机完成各类信息管理。以下是一些推荐的自考选题方向：基于SSM的毕业设计管理系统的设计与实现基于SSM大学生校园兼职论坛管理系统基于SSM的家教应聘招聘系统的设计和实现基于SpringBoot住院患者满意度跟踪调查系统的设计与实现基于SpringBoot在线作业提交系统的设计与实现总的来说，这些建议的选题方向覆盖了计算机
    
                    
    • 
                    
  • 主流行架构
                        rainbowcheng
架构架构
                        
    nexus，gitlab,svn,jenkins,sonar,docker，apollo，catteambition，axure，蓝湖，禅道,WCP；redis，kafka，es，zookeeper，dubbo，shardingjdbc，mysql，InfluxDB，Telegraf，Grafana，Nginx，xxl-job，Neo4j,NebulaGraph是一个高性能的,NOSQL图形数据库
    
                    
    • 
                    
  • springboot+mybatisplus实现基本的增删改查以及分页查询。这里使用的是Restful风格包括简单描述Restful是什么
                        okchan666
springbootjava
                        
    先实现springboot+mybatisplus的增删改查接口使用postman测试：第一步创建项目导入依赖：直接给大家了：4.0.0org.springframework.bootspring-boot-starter-parent2.6.6com.okchanspringboot_07_ssmp0.0.1-SNAPSHOT1.8org.springframework.bootspring-b
    
                    
    • 
                    
  • SpringBoot2：web开发常用功能实现及原理解析-整合EasyExcel实现Excel导入导出功能
                        生产队队长
SpringAllexcelspringboot
                        
    1、工程包结构主要是这5个Java类2、导入EasyExcel包这里同时贴出其他相关springboot的基础包org.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-devtoolsruntimetrueorg.springframework.bootspring-boot-config
    
                    
    • 
                    
  • nacos管理springboot配置时，发生的Could not resolve placeholder两种原因
                        生产队队长
SpringAllspringboot
                        
    IllegalArgumentException:Couldnotresolveplaceholder'xxx.xxx.xxx'invalue"${xxx.xxx.xxx}"第一种：确实缺少配置，加上对应的配置即可。第二种：这个情况，可能会迷惑很多人报错某个配置无法引用，但是，检查配置时，确实存在，已经配置好了。而且，整个yml文件也没有语法格式错误。原因：我们在解决第一个问题的时候，可能导致这个
    
                    
    • 
                    
  • springboot整合MongoDB时碰到的问题
                        生产队队长
DatabaseSpringAllmongodbspring
                        
    1.账号总是不对，导致查不出数据，报错Auth…权鉴错误这次，我也是第一次接触MongoDB，非常的生疏springboot整合MongoDB，要在properties文件中配置账号mongodb基本语法：useDATABASE_NAME;--创建数据库showdbs;--查看我们所有的库，注意，我们刚创建的库，如果没有数据，是不会被显示的showusers;--查看当前库所有拥有的账号db.cr
    
                    
    • 
                    
  • 深入解析 Dubbo 的 attachments 机制及其应用场景
                        molashaonian
dubboattachments隐式传参
                        
    背景在分布式系统中，服务之间的调用（RPC调用）是非常常见的。而在这种服务调用过程中，常常需要在不同服务之间传递一些上下文信息，比如用户身份信息、请求追踪ID、客户端IP等。Dubbo提供的attachments机制，能够帮助开发者在RPC调用时隐式传递这些数据，而不需要修改接口方法签名。通过分析架构图，我们可以看到，在服务调用链路中，使用Dubbo的attachments机制可以简化上下文信息的
    
                    
    • 
                    
  • python基于django/flask的NBA球员大数据分析与可视化python+java+node.js
                        QQ_511008285
pythondjangoflaskjavaspringboot数据分析
                        
    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以本文针对NBA球员的大数据进行
    
                    
    • 
                    
  • Java基于spring boot的国产电影数据分析与可视化python+java+node.js
                        QQ_511008285
javaspringboot数据分析pythondjangovue.jsflask
                        
    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以  该系统使用进行大数据处理和
    
                    
    • 
                    
  • 自己实现一个简易RPC调用框架
                        殷俊杰

                        
    最近在看dubbo，去创始人之一梁飞大神的博客搂了几眼，找到这个demo自己实现了一下，关于dubbo就不再介绍了，快速开始、框架设计、设计原则官网都有，有兴趣可以自己看Dubbo官网1.服务接口packagecom.yjj.my.api;/***@Description:*@Author:yinjunjie*@CreateDate:2018/8/713:16*@Version:1.0*/publ
    
                    
    • 
                    
  • SpringBoot—集成AOP详解（面向切面编程Aspect）
                        Hughman

                        
    AOP介绍AOP概述  AOP是Aspect-OrientedProgramming，即为面向（切面）方面编程。在维基百科中的解释：Aspect是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点。从关注点中分离出横切关注点是面向切面的程序设计核心概念。分离关注点使得解决特定领域问题的代码从业务逻辑中独立出来，业务逻辑代码不需要再包含针对特定领域问题代码的调用，比如一些公用模块的日志、
    
                    
    • 
                                
  • knob UI插件使用
                                    换个号韩国红果果
JavaScriptjsonpknob
                                    
    图形是用canvas绘制的 
 

js代码
var paras = {
			max:800,
			min:100,
			skin:'tron',//button type
			thickness:.3,//button width
			width:'200',//define canvas width.,canvas height
			displayInput:'tr
    
                                
    • 
                                
  • Android+Jquery Mobile学习系列(5)-SQLite数据库
                                    白糖_
JQuery Mobile
                                    
    目录导航 
  
SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。 
  
因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。 
  
我也是第一次接触S
    
                                
    • 
                                
  • impala-2.1.2-CDH5.3.2
                                    dayutianfei
impala
                                    
    最近在整理impala编译的东西，简单记录几个要点： 
根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）： 
1. 首次编译impala，推荐使用命令： 
${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format 
2.仅编译BE 
${I
    
                                
    • 
                                
  • 求二进制数中1的个数
                                    周凡杨
java算法二进制
                                    
    解法一：    
对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。  
   
   public int bitCount(int x){

       int count = 0;

       while(x!=0){

        if(x%2!=0){  /
    
                                
    • 
                                
  • spring中hibernate及事务配置
                                    g21121
Hibernate
                                    
    hibernate的sessionFactory配置： 
<!-- hibernate sessionFactory配置 -->
<bean id="sessionFactory"
	class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
	<
    
                                
    • 
                                
  • log4j.properties 使用
                                    510888780
log4j
                                    
    log4j.properties 使用 
一.参数意义说明 
输出级别的种类 
ERROR、WARN、INFO、DEBUG 
ERROR 为严重错误 主要是程序的错误 
WARN 为一般警告，比如session丢失 
INFO 为一般要显示的信息，比如登录登出 
DEBUG 为程序的调试信息 
配置日志信息输出目的地 
log4j.appender.appenderName = fully.qua
    
                                
    • 
                                
  • Spring mvc-jfreeChart柱图（2）
                                    布衣凌宇
jfreechart
                                    
    上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。 
第一步：导包 
第二步；配置web.xml(上一篇有代码) 
 
建BarRenderer类用于柱子颜色 
 
import java.awt.Color; 
import java.awt.Paint; 
import org.jfree.chart.renderer.category.BarR
    
                                
    • 
                                
  • 我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer
                                    aijuans
Spring3
                                    
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。 
PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
    
                                
    • 
                                
  • maven 之 cobertura 简单使用
                                    antlove
maventestunitcoberturareport
                                    
    1. 创建一个maven项目 
2. 创建com.CoberturaStart.java 
package com;

public class CoberturaStart {
	public void helloEveryone(){
		System.out.println("=================================================
    
                                
    • 
                                
  • 程序的执行顺序
                                    百合不是茶
JAVA执行顺序
                                    
      
  
  刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧 
  
代码如下; 
    经典的程序执行面试题 
//关于程序执行的顺序   
//例如：   
//定义一个基类   
public class A(){   
public A(
    
                                
    • 
                                
  • 设置session失效的几种方法
                                    bijian1013
web.xmlsession失效监听器
                                    
    在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
    
                                
    • 
                                
  • java jvm常用命令工具
                                    bijian1013
javajvm
                                    
    一.概述 
        程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。 本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具: 
      &nbs
    
                                
    • 
                                
  • 【Spring框架一】Spring常用注解之Autowired和Resource注解
                                    bit1129
Spring常用注解
                                    
    Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个： 
 
 Autowired 
 Resource 
 Component 
 Service 
 Controller 
 Transactional 
 
根据它们的功能、目的，可以分为三组，Autow
    
                                
    • 
                                
  • mysql 操作遇到safe update mode问题
                                    bitray
update
                                    
        我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全. 
 
    在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行 
SET
    
                                
    • 
                                
  • nginx_perl试用
                                    ronin47
nginx_perl试用
                                    
    因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl 
这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
    
                                
    • 
                                
  • java-63-在字符串中删除特定的字符
                                    bylijinnan
java
                                    
    

public class DeleteSpecificChars {

	/**
	 * Q 63 在字符串中删除特定的字符
	 * 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。
	 * 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.”
	 */
	public static voi
    
                                
    • 
                                
  • EffectiveJava--创建和销毁对象
                                    ccii
创建和销毁对象
                                    
    本章内容： 
1. 考虑用静态工厂方法代替构造器 
2. 遇到多个构造器参数时要考虑用构建器（Builder模式） 
3. 用私有构造器或者枚举类型强化Singleton属性 
4. 通过私有构造器强化不可实例化的能力 
5. 避免创建不必要的对象 
6. 消除过期的对象引用 
7. 避免使用终结方法 
 
 
1. 考虑用静态工厂方法代替构造器 
    类可以通过
    
                                
    • 
                                
  • [宇宙时代]四边形理论与光速飞行
                                    comsci

                                    
       从四边形理论来推论 为什么光子飞船必须获得星光信号才能够进行光速飞行？ 
 
 
   一组星体组成星座  向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说  一组频率就代表一个时空的入口 
 
   那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
    
                                
    • 
                                
  • ubuntu server下python脚本迁移数据
                                    cywhoyi
pythonKettlepymysqlcx_Oracleubuntu server
                                    
    因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql， 
但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602 
1.安装python 
2.安装pip、pymysql
    
                                
    • 
                                
  • Ajax正确但是请求不到值解决方案
                                    dashuaifu
Ajaxasync
                                    
    Ajax正确但是请求不到值解决方案 
  
解决方案：1 .     async: false ,    2.     设置延时执行js里的ajax或者延时后台java方法！！！！！！！ 
  
例如： 
  
$.ajax({     &
    
                                
    • 
                                
  • windows安装配置php+memcached
                                    dcj3sjt126com
PHPInstallmemcache
                                    
    Windows下Memcached的安装配置方法 
1、将第一个包解压放某个盘下面，比如在c:\memcached。 
2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。 
3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
    
                                
    • 
                                
  • iOS开发学习路径的一些建议
                                    dcj3sjt126com
ios
                                    
    iOS论坛里有朋友要求回答帖子，帖子的标题是： 想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759 
  
下面是我回复的内容： 
  
结合自己情况聊下iOS学习建议，
    
                                
    • 
                                
  • Javascript闭包概念
                                    fanfanlovey
JavaScript闭包
                                    
    1.参考资料 
 
 
 
http://www.jb51.net/article/24101.htm 
 
 
http://blog.csdn.net/yn49782026/article/details/8549462 
 
 
 
 
 
 
2.内容概述 
要理解闭包，首先需要理解变量作用域问题 
内部函数可以饮用外面全局变量 
 
    var n=999;

　　functio
    
                                
    • 
                                
  • yum安装mysql5.6
                                    haisheng
mysql
                                    
    1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm 
  
2、yum install mysql 
  
3、yum install mysql-server 
  
4、vi /etc/my.cnf   添加character_set_server=utf8
    
                                
    • 
                                
  • po/bo/vo/dao/pojo的详介
                                    IT_zhlp80
javaBOVODAOPOJOpo
                                    
        JAVA几种对象的解释 
PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作. 
VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
    
                                
    • 
                                
  • java设计模式
                                    kerryg
java设计模式
                                    
    设计模式的分类： 
   一、 设计模式总体分为三大类： 
 1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 
 2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 
 3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
    
                                
    • 
                                
  • [1]CXF3.1整合Spring开发webservice——helloworld篇
                                    木头.java
springwebserviceCXF
                                    
    Spring 版本3.2.10 
CXF 版本3.1.1 
项目采用MAVEN组织依赖jar 
 
 
我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本 
 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
    
                                
    • 
                                
  • Google 工程师亲授：菜鸟开发者一定要投资的十大目标
                                    qindongliang1922
工作感悟人生
                                    
    身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写））  你的健康  无疑地，软件开发者是世界上最久坐不动的职业之一。  每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
    
                                
    • 
                                
  • linux打开最大文件数量1,048,576
                                    tianzhihehe
clinux
                                    
    File descriptors are represented by the C int type. Not using a special type is often  considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
    
                                
    • 
                                
  • java语言中PO、VO、DAO、BO、POJO几种对象的解释
                                    衞酆夼
javaVOBOPOJOpo
                                    
    PO:persistant object持久对象 
最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 
 
BO:business object业务对象 
封装业务逻辑的java对象
    
                                
    •