easymall项目

@Configuration
@ConfigurationProperties(prefix="redis.cluster")
public class ClusterConfig {
	//四个属性
	private List<String> nodes;
	private Integer maxIdle;
	private Integer maxTotal;
	private Integer minIdle;
	//初始化读取属性后,创建bean对象JedisCluster
	@Bean
	public JedisCluster initJedisCluster(){
		//收集节点信息
		Set<HostAndPort> set=new HashSet<HostAndPort>();
		for(String node:nodes){
			//每次循环拿到ip:port
			String host=node.split(":")[0];
			int port=Integer.parseInt(node.split(":")[1]);
			set.add(new HostAndPort(host, port));
		}
		//配置对象
		GenericObjectPoolConfig config=new GenericObjectPoolConfig();
		config.setMaxTotal(maxTotal);
		config.setMaxIdle(maxIdle);
		config.setMinIdle(minIdle);
		//创建JedisCluster对象
		return new JedisCluster(set,config);
	}
	public List<String> getNodes() {
		return nodes;
	}
	public void setNodes(List<String> nodes) {
		this.nodes = nodes;
	}
	public Integer getMaxIdle() {
		return maxIdle;
	}
	public void setMaxIdle(Integer maxIdle) {
		this.maxIdle = maxIdle;
	}
	public Integer getMaxTotal() {
		return maxTotal;
	}
	public void setMaxTotal(Integer maxTotal) {
		this.maxTotal = maxTotal;
	}
	public Integer getMinIdle() {
		return minIdle;
	}
	public void setMinIdle(Integer minIdle) {
		this.minIdle = minIdle;
	}
	
}

@SpringBootApplication
@MapperScan("cn.tedu.product.mapper")
@EnableEurekaClient
public class StarterProductService {
	public static void main(String[] args) {
		SpringApplication.run(StarterProductService.class, args);
	}
}

@RestController
@RequestMapping("/product/manage")
public class ProductController {
	@Autowired
	private ProductService productService;
	//分页查询功能
	
	@RequestMapping("pageManage")
	public EasyUIResult queryPageProducts(Integer page,Integer rows){
		//page:页数
		//rows:每页的条数
		//在业务层封装EasyYIResult对象
		EasyUIResult result= productService.queryPageProducts(page,rows);
		return result;
	}
}

@Service
public class ProductService {
	@Autowired
	private ProductMapper productMapper;
	public EasyUIResult queryPageProducts(Integer page, Integer rows) {
		//准备EasyUIResult 
		EasyUIResult result=new EasyUIResult();
		//total
		int total=productMapper.selectProductCount();
		
		result.setTotal(total);
		//rows List<Product>对象
		int start=(page-1)*rows;
		List<Product> pList=productMapper.selectProductList(start,rows);
		result.setRows(pList);
		return result;
	}
}

public interface ProductMapper {
	public int selectProductCount();
	//在方法中存在多个参数,使用Param注解,实现parameter的翻译导入
	public List<Product> selectProductList(@Param("start")int start, @Param("rows")Integer rows);
}

@RequestMapping("item/{productId}")
	public Product queryProduct(@PathVariable String productId){
		return productService.queryProduct(productId);
	}

@Autowired
	private JedisCluster cluster;
	
	public Product queryProduct(String productId) {
		//引入缓存判断更新锁的存在
		//生成当前逻辑中需要的key
		//锁的key product_update_productId+.lock
		String updateLock="product_update_"+productId+".lock";
		String productKey="product_"+productId;
		//判断锁是否存在
		try{
			if(cluster.exists(updateLock)){
				//锁存在,有人更新数据,缓存就不能使用
				return productMapper.selectProductById(productId);
			}else{
				//锁不存在,判断缓存逻辑
				if(cluster.exists(productKey)){
					//src就是json字符串
					//value class对象解析的类反射对象
					return MapperUtil.MP.readValue(cluster.get(productKey), Product.class);
				}else{
					//查持久层
					Product product=productMapper.selectProductById(productId);
					//加入缓存 维护少量数据的写入缓存
					cluster.setex(productKey,60*60*2,MapperUtil.MP.writeValueAsString(product));
					return product;
				}
			}
		}catch(Exception e){
			e.printStackTrace();
			return null;
		}	
	}

public Product selectProductById(String productId);

@RequestMapping("save")
	public SysResult deployProduct(Product product){
		//判断成功失败逻辑
		try{
			productService.deployProduct(product);
			//表示成功200 其他表示失败
			return SysResult.ok();
			//{"status":200,"msg":"ok","data":null}
		}catch(Exception e){
			e.printStackTrace();
			return SysResult.build(201, e.getMessage(), null);
		}
	}

public void deployProduct(Product product) {
		//补齐数据uuid保存productId
		product.setProductId(UUID.randomUUID().toString());
		productMapper.insertProduct(product);
		
	}

	public void insertProduct(Product product);

@RequestMapping("update")
	public SysResult renewProduct(Product product){
		try{
			productService.renewProduct(product);
			//成功调用返回200 result
			return SysResult.ok();
		}catch(Exception e){
			e.printStackTrace();
			return SysResult.build(201, e.getMessage(), null);
		}
	}

public void renewProduct(Product product) {
		/*1.加锁(超时时间,10分钟)
		 *2.删除缓存productKey
		 *3.更新数据库
		 *4.释放锁   
		 */
		String updateLock="product_update_"+product.getProductId()+".lock";
		String productKey="product_"+product.getProductId();
		cluster.setex(updateLock, 60*5,"");
		cluster.del(productKey);
		productMapper.updateProductById(product);
		cluster.del(updateLock);
	}

@RequestMapping("checkUserName")
	public SysResult checkUserName(String userName){
		//控制层判断查询结果可用不可用
		int exists=userService.checkUserExists(userName);
		// 1或0 1表示不可用:201 0表示可用:200
		if(exists==1){
			return SysResult.build(201, "不可用", null);
		}else{
			return SysResult.ok();
		}
		
	}

public int checkUserExists(String userName) {
		//1存在 0不存在
		return userMapper.selectUserCountByUserName(userName);
	}

	public int selectUserCountByUserName(String userName);

@RequestMapping("save")
	public SysResult doRegister(User user){
		try{
			userService.doRegister(user);
			return SysResult.ok();
		}catch(Exception e){
			e.printStackTrace();
			return SysResult.build(201, "注册失败", null);
		}
	}

public void doRegister(User user) {
		//补齐一个userId
		user.setUserId(UUID.randomUUID().toString());
		//对密码进行加密
		//对密码加密方式 安全可以使用md5加盐
		//user.getUserPassword
		user.setUserPassword(MD5Util.md5(user.getUserPassword()));
		userMapper.insertUser(user);
	}

	public void insertUser(User user);

@RequestMapping("login")
	public SysResult doLogin(User user,HttpServletRequest req,HttpServletResponse res){
		//通过业务层返回的数据ticket是否为空判断
		//登陆逻辑是否正常 ""正常值
		String ticket=userService.doLogin(user);
		if("".equals(ticket)){
			//登录失败
			return SysResult.build(201, "", null);
		}else{
			//ticket不为空,说明登陆成功
			//返回成功信息之前,要在cookie中定义一个携带ticket的头的信息EM_TICKET
			CookieUtils.setCookie(req, res, "EM_TICKET", ticket);
			return SysResult.ok();
		}
	}

public String doLogin(User user) {
		//判断登陆权限校验 select where username and password
		//加密
		user.setUserPassword(MD5Util.md5(user.getUserPassword()));
		User exits = userMapper.selectUserByUserNameAndPassword(user);
		String loginKey="login_"+user.getUserName();
		String newTicket="";
		//判断loginKey是不是存在
		if(jedis.exists(loginKey)){
			//曾经有人登陆过
			String oldTicket=jedis.get(loginKey);
			jedis.del(jedis.get(loginKey));
			jedis.del(oldTicket);
		}
		//正常设置newTicket-userJson
		try{
			newTicket="EM_TICKET"+System.currentTimeMillis()+exits.getUserId();
			String userJson=MapperUtil.MP.writeValueAsString(exits);
			jedis.setex(newTicket, 60*60*2, userJson);
			//设置有效的ticket使用
			jedis.setex(loginKey,60*60*2,newTicket);
		}catch(Exception e){
			e.printStackTrace();
			return "";
		}
		return newTicket;	
	}

public User selectUserByUserNameAndPassword(User user);

@RequestMapping("query/{ticket}")
	public SysResult queryTicket(@PathVariable String ticket){
		String userJson=userService.queryTicket(ticket);
		if(userJson==null){
			//超过两小时
			return SysResult.build(201, "用户超时", null);
		}else{
			//登录状态可用
			return SysResult.build(200, "登陆状态可用", userJson);
		}
	}

public String queryTicket(String ticket) {
		//判断剩余时间
		Long leftTime=jedis.pttl(ticket);
		if(leftTime<1000*60*30){
			//小于30分钟,续约一小时
			jedis.pexpire(ticket, leftTime+1000*60*60);
		}
		return jedis.get(ticket);
}

@SpringBootApplication
@MapperScan("cn.tedu.cart.mapper")
@EnableEurekaClient
public class StarterCartService {
	public static void main(String[] args) {
		SpringApplication.run(StarterCartService.class, args);
	}
	//ribbon 创建一个可以负载均衡的访问服务对象
	@Bean
	@LoadBalanced
	public RestTemplate initRestTemplate(){
		return new RestTemplate();
	}
}

// 查询我的购物车
	@RequestMapping("query")
	public List<Cart> queryMyCarts(String userId) {
		return cartService.queryMyCarts(userId);
	}

public List<Cart> queryMyCarts(String userId) {
		
		return cartMapper.selectCartsByUserId(userId);
	}

public List<Cart> selectCartsByUserId(String userId);

@RequestMapping("save")
	public SysResult saveMyCart(Cart cart) {
		try {
			cartService.saveMyCart(cart);
			return SysResult.ok();
		} catch (Exception e) {
			e.printStackTrace();
			return SysResult.build(201, "新增购物车失败", null);
		}
	}

@Autowired
	private RestTemplate client;
	public void saveMyCart(Cart cart) {
		//查询已有
		Cart exist=cartMapper.selectExistByUserIdAndProductId(cart);
		if(exist!=null){
			//已存在 更新num的数量
			//更新内存对象数据
			cart.setNum(cart.getNum()+exist.getNum());
			cartMapper.updateCartNumByUserIdAndProductId(cart);
		}else{
			//没数据 新增购物车
			//获取商品服务返回的数据,封装补齐cart对象
			Product product=client.getForObject("http://productservice/product/manage/item/"+cart.getProductId(), Product.class);
			cart.setProductImage(product.getProductImgurl());
			cart.setProductName(product.getProductName());
			cart.setProductPrice(product.getProductPrice());
			//调用insert语句
			cartMapper.insertCart(cart);
		}
	}

public List<Cart> selectCartsByUserId(String userId);

	public void insertCart(Cart cart);

	public void updateCartNumByUserIdAndProductId(Cart cart);

	public Cart selectExistByUserIdAndProductId(Cart cart);

@RequestMapping("update")
	public SysResult updateMyCartNum(Cart cart){
		try{
			cartService.updateMyCartNum(cart);
			return SysResult.ok();
		}catch(Exception e){
			e.printStackTrace();
			return SysResult.build(201, "更新失败", null);
		}
	}

public void updateMyCartNum(Cart cart) {
		cartMapper.updateCartNumByUserIdAndProductId(cart);
	}

public void updateCartNumByUserIdAndProductId(Cart cart);

//购物车的删除
	@RequestMapping("delete")
	public SysResult deleteMyCart(Cart cart){
		try{
			cartService.deleteMyCart(cart);
			return SysResult.ok();
		}catch(Exception e){
			e.printStackTrace();
			return SysResult.build(201, "删除失败", null);
		}
	}

public void deleteMyCart(Cart cart) {
		cartMapper.deleteCartByUserIdAndProductId(cart);
	}

public void deleteCartByUserIdAndProductId(Cart cart);

//查询我的订单
	@RequestMapping("query/{userId}")
	public List<Order> queryMyOrders(@PathVariable String userId){
		return orderService.queryMyOrders(userId);
}

public List<Order> queryMyOrders(String userId) {
		
		return orderMapper.selectOrdersByUserId(userId);
	}

List<Order> selectOrdersByUserId(String userId);

//新增订单
		@RequestMapping("save")
		public SysResult saveOrder(Order order){
			try{
				orderService.saveOrder(order);
				return SysResult.ok();
			}catch(Exception e){
				e.printStackTrace();
				return SysResult.build(201, "", null);
			}
}

public void saveOrder(Order order) {
		//补齐数据orderId orderTime orderPaystate
		order.setOrderId(UUID.randomUUID().toString());
		order.setOrderTime(new Date());
		order.setOrderPaystate(0);
		orderMapper.insertOrder(order);		
}

void insertOrder(Order order);

//删除
	@RequestMapping("delete/{orderId}")
	public SysResult deleteOrder(@PathVariable String orderId){
		try{
			orderService.deleteOrder(orderId);
			return SysResult.ok();
		}catch(Exception e){
			e.printStackTrace();
			return SysResult.build(201, "", null);
		}
		
}

public void deleteOrder(String orderId) {
		orderMapper.deleteOrderByOrderId(orderId);	
	}

void deleteOrderByOrderId(String orderId);

@RestController

public class ImgController {
	@Autowired
	private ImgService imgService;
	//图片上传
	@RequestMapping("/pic/upload")
	public PicUploadResult picUpload(MultipartFile pic){
		//{"url":"http://image.jt.com/upload/**"}
		return imgService.picUpload(pic);
	}
}

@Service
public class ImgService {
	@Value("${diskPath}")
	private String path;
	@Value("${urlPath}")
	private String urlPath;
	public PicUploadResult picUpload(MultipartFile pic) {
		//主要思路:将图片存储在本地C盘 返回url地址
		/*
		 * 1.获取图片名称
		 * 2.判断图片合法(后缀名)
		 * 	2.1成功:继续逻辑
		 * 	2.2失败:Result error=1 return
		 * 3.根据图片的原名称生成一个路径的多级地址字符串
		 *  /upload/1/d/3/e/3/d/3/3/ 原名称不变,对应的目录一个  
		 * 4.生成磁盘路径file mkdir
		 * 	@Value("${path}")+dir
		 * 5.重命名文件 uuid.jpg
		 * 6.输出pic中的流数据到磁盘中形成一个图片文件 
		 * 7.拼接url地址 @Value("${urlPath}")+dir+重命名
		 * 8.数据赋值返回
		 */
		
		//准备一个返回的对象
		PicUploadResult result =new PicUploadResult();
	
		try{
			
			//文件名称校验
			//拿到原名 **.jpg
			String oldName=pic.getOriginalFilename();
			//截取后缀名.jpg .png .bmp
			String extName=oldName.substring(oldName.lastIndexOf("."));
			//判断后缀合法
			if(!extName.matches(".(png|jpg|git)$")){
				result.setError(1);
				return result;
			}
			//使用工具类生成一个多级路径地址,以upload开始的
			String dir="/"+UploadUtil.getUploadPath(oldName, "upload")+"/";
			//创建文件夹,文件夹可能存在,也可能不存在
			File _dir=new File(path+dir);
			if(!_dir.exists()){
				//文件不存在
				_dir.mkdirs();
			}
			//重命名文件
			String fileName=UUID.randomUUID().toString()+extName;
			//xxx.jpg
			//将这个名称作为文件存储图片数据
			pic.transferTo(new File(path+dir+fileName));
			//result封装url地址
			String url=urlPath+dir+fileName;
			return result;
		}catch(Exception e){
			e.printStackTrace();
			result.setError(1);
			return result;
		}
		
	}

}

@Configuration
@ConfigurationProperties(prefix="easymall.es")
public class ESConfig {
	//集群名称
	private String clusterName;
	//节点连接node信息
	private List<String> nodes;
	//初始化方法对象
	@Bean
	public TransportClient initTransportClient(){
		//setting对象,包装clusterName
		Settings set=Settings.builder().put("cluster.name","elasticsearch").build();
		TransportClient client=new PreBuiltTransportClient(set);
			try {
				
				for(String node:nodes){
					String host=node.split(":")[0];
					int port=Integer.parseInt(node.split(":")[1]);
					InetSocketTransportAddress ista1=new InetSocketTransportAddress(InetAddress.getByName(host), port);
					client.addTransportAddress(ista1);
					}
				 
			} catch (UnknownHostException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return client;

		}
	
	public String getClusterName() {
		return clusterName;
	}
	public void setClusterName(String clusterName) {
		this.clusterName = clusterName;
	}
	public List<String> getNodes() {
		return nodes;
	}
	public void setNodes(List<String> nodes) {
		this.nodes = nodes;
	}
	
}

@RestController
public class ESSearchController {
	@Autowired
	private ESSearchService searchService;
	@RequestMapping("search/manage/query")
	public List<Product> searchByName(String query,Integer page,Integer rows){
		return searchService.searchByName(query,page,rows);
		
	}
}

@Service
public class ESSearchService {
	@Autowired
	private TransportClient client;

	public List<Product> searchByName(String text, Integer page, Integer rows) {
		//创建query对象,封装查询条件MatchQuery
		MatchQueryBuilder query=QueryBuilders.matchQuery("productName", text);
		//根据分页条件创建请求request
		SearchRequestBuilder request=client.prepareSearch("easymall");
		request.setQuery(query).setFrom((page-1)*rows).setSize(rows);
		//发送请求,获取查询结果集
		SearchResponse response=request.get();
		//解析封装了hits的结果集,每个元素中使用source反序列化
		SearchHit[] hits=response.getHits().getHits();
		//准备一个空list
		List<Product> pList=new ArrayList<Product>();
		for(SearchHit hit:hits){
			String pJson=hit.getSourceAsString();
			try{
				Product product=MapperUtil.MP.readValue(pJson, Product.class);
				pList.add(product);
			}catch(Exception e){
				e.printStackTrace();
				return null;
			}
		}
		return pList;
	}
}