jy-16-T-STORE——陈子枢总结

最新推荐文章于 2024-07-16 23:48:03 发布

从码农到码到成功

最新推荐文章于 2024-07-16 23:48:03 发布

阅读量333

点赞数

文章标签： eclipse maven java

本文链接：https://blog.csdn.net/weixin_39519454/article/details/121025679

版权

1、day01——1、基础环境：

配置一定要配置jdk的环境

下载jdk1.7/jdk1.8
两种jdk，安装版本（windows dll注册表），绿色解压版本D:/java-env/jdk1.7+jdk1.8，

很多软件都有配置文件，在配置文件中强行指定JAVA_HOME的路径。Eclipse.ini，相当于设置了临时环境。就实现多个版本并存。

实际开发中在一台计算机上安装多个jdk，1.7+1.8

Eclipse中配置jdk。进入eclipse的window菜单，prefenrece菜单

绿色安装版本，所放置的目录中不应该含有中文或特殊字符，不应该有空格。

配置maven环境，给eclipse配置自己安装的不要用默认自带的，因为它有很多bug。

官网或者镜像网站下载maven
绿色解压放入目录即可D:\tts9\apache-maven-3.3.9
配置到eclipse，不用它自带有Bug的版本

不用默认的，新增自己去现在绿色解压版的maven，选择它的根目录

创建完成，一定要打钩，否则eclipse并未启用。

Maven骨架很烂，很多Bug，例如用着用着，骨架创建不了了。

骨架：quickstart 针对java工程/webapp 针对web工程。

遇到弹出一个框，提示骨架损坏了，无法继续创建。

解决方案：

联网：把骨架删除，骨架就是本地的仓库中的jar。如果eclipse调用会自动去判断，如果jar包，自动去网上下载，就去中央仓库或者私服去下载。重写下载后就可以使用、
没有联网：从一台同学好的仓库中把目录拷贝过来，重新启动eclipse即可。

骨架目录在哪里呢？

C:\Users\adminitartor\.m2\repository\org\apache\maven\archetypes

settings.xml

默认：中央仓库

可以配置镜像仓库（私服）

<mirrors>
<mirror>
<id>nexus</id>
<name>Tedu Maven</name>
<mirrorOf>*</mirrorOf>
<url>http://maven.tedu.cn/nexus/content/groups/public</url>
<!-- <url>http://maven.oschina.net/content/groups/public</url> -->
</mirror>
</mirrors>

配置到tedu的私服

Ts-parent 父工程pom，没有直接的骨架，先利用java骨架，然后修改pom.xml文件中工程类型由jar改成pom类型。

修改类型jar修改为pom，它就是一个父工程

父工程

Pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>cn.ts</groupId>
<artifactId>ts2-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>

<name>ts2-parent</name>
<url>http://maven.apache.org</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>

<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.9</version>
</dependency>

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.2.8</version>
</dependency>

<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>

<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.2.3</version>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.2.3</version>
</dependency>

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.2.3</version>
</dependency>


<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>

<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.0</version>
</dependency>

<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjtools</artifactId>
<version>1.8.0</version>
</dependency>

<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>3.16</version>
</dependency>

<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.3</version>
</dependency>

<!-- JSP相关 -->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>

</dependencies>
</project>

配置完成后就应该立即发布

项目名称上点击右键，菜单中选择Run as中选择Maven install

它就执行eclipse配置的maven下的命令。

如果提示 “BUILD SUCCESS”代表代码没有问题，通过。如果不是，代码有问题，根据错误提示进行修改。

工具类工程

ts2-common jar工程

权限管理聚合工程

ts2-manage jar工程修改为pom工程，选择parent父项目ts2-parent

创建聚合的子工程，选择Maven Module方式创建

ts2-manage-mapper依赖ts2-manage-pojo

Ts2-manage-web

除了修改jdk的两处外，还有额外的修改一处，总共3处

都要install，必须出现SUCCESS提示，否则找原因，修改。

传统方式，在eclipse配置servers，还要配置一个tomcat（server.xml中配置8080默认端口）。发布程序add/remove项目。

Maven提供简化方式，快速配置，快速启动。

http://localhost:8080/TeduStore/user/address.do

TeduStore 虚拟路径，可以自己配置虚拟路径的名称，如果不配置，eclipse默认设置的是项目名称。

<port>8090</port> 可以通过maven的tomcat插件，快速定义端口号

<path>/</path> 可以通过maven的tomcat插件，快速定义虚拟路径，定义在根

</configuration>

本地仓库中就有了一个微缩版本的tomcat，不用自己下载一个tomcat。不用部署war到tomcat中。环境配置就非常迅速

C:\Users\adminitartor\.m2\repository

\org\apache\tomcat\maven\tomcat7-maven-plugin\2.2

怎么启动tomcat插件呢？

在eclipse的调试菜单上来配置环境，运行maven命令。

在调试要进行配置，配置一次即可

找到MavenBuild选项，然后右键菜单，选择new

创建运行快捷方式，选择运行项目（web项目）

选择要执行web项目，配置maven执行命令 tomcat7:run，会自动发布war，会自动启动tomcat（插件）

跟踪调试时，要进入到断点，需要多个的项目，例如：ts2-manage-service,ts2-manage-controller。要能进入到这个断点，必须在这里来设置。

虽然选项很多，只有一个起作用，Java Project。

选择时，为了简单，把这个项目web，相关的调用的所有的项目都选择。

最后一个选项，选择utf-8，防止中文乱码问题。

断点调试就非常方便，可以跨越多个工程。

回顾今天知识：

传统小型项目，特点：所有的业务模块都在一个项目中，例如：学子商城，包括：权限管理模块、订单模块、购物车模块等等。

开发人员统一拷贝复制整个项目代码，分小组去维护。一个团队分为多个小组。做权限模块的小组，做订单模块的小组，做购物车模块的小组。

因为项目小，所以所有的开发人员基本在一起。如果发生问题，当面沟通，迅速解决。修改的代码复制拷贝过来。有新的代码了。

大型项目，特点：人员众多。分散。项目庞大，京淘商城，后台系统，前台系统，单点登录SSO系统，购物车系统，订单系统，商品搜索系统，权限系统，支付系统等。

把一个大的系统分拆成很多小的系统，小的系统尽量单独维护。

分拆方式：

垂直拆分（纵向），按业务来拆分，把原来系统中的业务模块升级成子系统
水平拆分（横向），一个子系统内还很多内容，继续分拆。也分层体系架构来分拆。pojo/mapper/service/controller(web)

Maven诞生以后就更加方便这种分拆体系。

垂直分拆产生两个新的项目，这是以前就的方式中没有的内容。

Ts-parent 父项目，作用：统一管理jar。项目类型为：pom

Ts-common 工具类项目，作用：统一全局工具类工程，其它项目要调用工具类，依赖。项目类型为：jar

权限系统结构：

Ts-manage 聚合项目，作用：一键发布，更快更方便的编译，项目类型为：pom。它是一个特殊的父工程。如何判定一个项目是父工程还是聚合工程？查看pom.xml，是否有<modules>，如果有聚合工程，如果没有就是一个普通的父工程。

问题：一个大型项目中有几个父工程？一个父工程足够。

问题：父工程中依赖jar，设定版本，其他子项目中能否还有这个jar的不同的版本？（父工程中设置junit 4.12，子工程如果需要junit3.8.1怎么办？ Jar冲突。子工程用的是3.8.1没有使用4.12版本，Maven规定自己的pom.xml的jar版本优先，一旦遇到冲突，找到第一个出口即结束。）

列表：

Junit 3.8.1

Junit4.12

Maven通过简单方式就排除了jar冲突。简单原则就是。本地优先。

水平拆分：

把每个子系统都要横向的分拆。不要嫌麻烦。

字段有关系：total=num*price

从大型项目的构建来说：

属于聚合工程的子项目：

特点：

聚合的子项目会放在聚合项目目录下

Ts-manage-pojo Pojo简单java对象类（property/get/set）

Ts-manage-mapper mybatis特有mapper的映射接口

Ts-manage-service 业务层，业务逻辑实现，接口+实现类

Ts-manage-controller/web 视图层，jsp/controller，静态资源（js/css/image/html），配置文件

Tomcat的Maven插件

传统部署方式：安装tomcat，配置servers+tomcat，部署war到tomcat中，启动停止tomcat。操作繁琐，运行速度慢。

插件使用2步：

pom.xml 中要依赖tomcat插件

<build>
<plugins>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<port>8090</port>
<path>/</path>
</configuration>
</plugin>
</plugins>
</build>

注意：

默认创建工程时，<build>标签会自动创建，pom.xml中只允许有一个bulid标签。要把旧的一定要删除
<port>8090</port> 不用去修改tomcat的server.xml文件来修改端口，而直接利用配置文件来修改，修改配置都方便很多
<path>/</path> 设置虚拟路径，/代表根目录，/TeduStore在访问时，在浏览器上地址栏输入虚拟路径。如果只是/就tomcat下就只能运行一个项目，如果各自有各自的虚拟路径，可以运行多个项目。
配置maven的tomcat插件是一个微缩版，它没有考虑性能优化、安全等内容。所以小快。如果企业最终部署系统到生产环境，还必须用tomcat，war的发布方式。只是测试环境方便快速测试。

配置一个当前项目的启动快捷maven命令的方式：

配置一个命令，一次配置，都可以使用、
配置时大多实际开发中都需要断点跟踪，观察局部变量值，是不是正确。

2、介绍：

陈子枢，3天

day08:Maven继承、聚合；jedis,跟spring整合，整合地址信息

day09:mysql 存储过程，索引，优化：最左前缀特性，表设计

dya10:健身项目（分析需求），美发项目（分析需求）

Maven干什么用的？项目管理

项目团队100，软件研发50人，直接使用Maven基础即可

项目团队1000（人员众多，项目组的人员分散全球各地）

传统项目，人少，就一个项目，大而全，所有的内容都放在其中

包括：

SpringMVC+Spring+Mybatis

Mybatis层（持久层）：接口(mapper)，映射文件中(mappers)

Spring层（业务层）：接口，实现类

SpringMVC层（控制层）：Controller

其他配置：web.xml(spring)、spring-mvc.xml(springmvc)

在eclipse上配置servers(tomcat 8080)，启动，停止

问题：

1）传统一个项目开发方式，不利于大型团队和异地团队开发（不同的业务交叉）

2）传统一个项目中各层交织，bean(pojo、domain)/mapper/service/controller

3)传统发布方式，要自己配置tomcat servers开发效率低

Maven管理大型团队的项目

1）业务垂直拆分（权限管理、订单、购物车...）

a.jar依赖会发生变化

2）业务的水平拆分（pojo/mapper/service/controller(web)）

3) maven它有个tomcat插件，启动快

练习：

1）画把项目垂直拆分和水平拆分，定项目名称

2）尝试把每个项目的类型标识出来：

pom父工程+聚合工程/jar只有jar包/war带jsp页面

小总结：

1）ts-parent pom 父工程，通用的jar都在父工程中管理

2）ts-common jar 工具类工程

3）ts-manage pom 聚合工程，作用？（水平拆分的子项目的集合）

4）ts-manage-pojo jar 日常model对象

5）ts-manage-mapper jar 持久层的接口文件

6）ts-manage-service jar 业务层的文件接口、实现类

7)ts-manage-web war 控制层，包括：controller，jsp,映射文件，其他的资源配置文件，静态的资源文件（js，css，image，html）

quickstart 创建jar类型骨架

webapp 创建war类型骨架

Maven项目中

1）父工程

2）聚合

3）各个工程直接依赖关系

Maven管理本地项目的jar/war和第三方的管理方式一样

其实本质就是在Maven的目录中创建坐标结构，把相应文件放入到对应目录中

Maven的右键菜单

1）clean当项目发布有问题，检查不是代码的问题，就先使用clean

2）install把项目发布，把相应文件放入到Maven仓库中

注意，

1）当ts-parent如果有jar依赖改变，必须install，否则其他工程引用时可能是旧的，程序就可能执行不正常

2）聚合工程上一次可以发布Install所有的子工程，按顺序调用

部署：

找一个tomcat，把war拷入，webapp工程引用的这些jar包怎么引用？

1）直接到Maven仓库中引用（错）

2）直接在war工程中的WEB-INF/lib目录下，所有引用的jar包（正确）

3、Maven的继承和聚合

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

<!-- JSP相关 -->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>

Maven垂直切分

ts-parent -- 父工程，pom类型，统一管理公用jar依赖

ts-common -- jar类型，通用的组件、工具类

ts-manage -- pom类型，后台管理系统，管理商品、分类等功能

Maven水平切分

ts-manage-pojo -- jar类型，后台持久类

ts-manage-mapper -- jar类型，后台持久层接口

ts-manage-service -- jar类型，后台业务层

ts-manage-web -- war类型，后台的前台controller、jsp、映射文件

依赖关系

ts-manage-mapper 依赖pojo

ts-manage-service 依赖pojo，依赖mapper，依赖common

ts-manage-web 依赖pojo，依赖mapper，依赖service，依赖common

利用依赖的传递性简化

pojo依赖common，mapper依赖pojo，service依赖mapper，web依赖service

Maven和Tomcat整合 =========================

<build>
<plugins>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<port>8090</port>
<path>/</path>
</configuration>
</plugin>
</plugins>
</build>

http://localhost:8090/main/index.do

jedis引入 =========================

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.6.0</version>
</dependency>

package jedis;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

public class TestJedis {
@Test    //完成单实例链接
public void jedis(){
//Jedis jedis = new Jedis("192.168.27.113", 6379);
Jedis jedis = new Jedis("192.168.163.7", 6379);
//jedis.auth("123456");
jedis.set("name", "tony3");    //调用redis命令set
System.out.println(jedis.get("name"));
jedis.close();
}

@Test
public void pool(){
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(200);

List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
JedisShardInfo info = new JedisShardInfo("192.168.163.7", 6379);
shards.add(info);

ShardedJedisPool pool = new ShardedJedisPool(config, shards);
ShardedJedis jedis = pool.getResource();

System.out.println(jedis.get("name"));
}
}

spring-redis.xml =========================

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

<!-- 构建连接池配置信息 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!-- 最大连接数 -->
<property name="maxTotal" value="200"/>
</bean>

<!-- 定义集群连接池 -->
<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool" destroy-method="close">
<!-- 第一个参数 -->
<constructor-arg index="0" ref="jedisPoolConfig"/>
<constructor-arg index="1">
<list>
<bean class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="192.168.163.7"/>
<constructor-arg type="int" index="1" value="6379"/>
</bean>
</list>
</constructor-arg>
</bean>

</beans>

DictServiceImpl ======================

package cn.tedu.store.service;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import cn.tedu.store.bean.dict.Area;
import cn.tedu.store.bean.dict.City;
import cn.tedu.store.bean.dict.Province;
import cn.tedu.store.mapper.DictMapper;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
@Service("dictService")
public class DictServiceImpl implements DictService {
@Resource
private DictMapper dictMapper;
@Resource
private ShardedJedisPool shardedJedisPool;
private static final ObjectMapper MAPPER = new ObjectMapper();
public List<Province> getProvinceList() {
return dictMapper.getProvinceList();
}
public List<City> getCityList(String provinceCode) {
ShardedJedis jedis = shardedJedisPool.getResource();
String RedisKey = "TS_CITY_"+provinceCode;
if(jedis.exists(RedisKey)){
Object obj = null;
try {
String json = jedis.get(RedisKey);
JsonNode jsonNode = MAPPER.readTree(json);
obj = MAPPER.readValue(jsonNode.traverse(),
MAPPER.getTypeFactory().constructCollectionType(List.class, City.class));
} catch (Exception e) {
e.printStackTrace();
}
return (List<City>) obj;
}else{
List<City> listCity = dictMapper.getCityList(provinceCode);
try {
String json = MAPPER.writeValueAsString(listCity);
jedis.set(RedisKey, json);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return listCity;
}
}
}

学子商场：

业务的垂直拆分

业务的水平拆分

2、day02- 01-数据库编程(了解)

数据库中可以编写并保存一段程序，做数据运算

视图 View
存储过程 Procudure
函数 Function
触发器 Trigger

mysql 数据库编程能力较弱，很多功能无法实现

2 变量

2.1 用户会话变量

一个客户端与服务器连接期间的变量

set @v1 = 123;
select @v1;

2.2 局部变量

begin ... end; 是一对大括号，局部变量只能在 begin 到 end 之间使用， end 结束后，变量消失

使用 declare 关键字来定义局部变量

delimiter ; 结束符改成 ;

delimiter // 结束符改成 //

创建复杂的存储过程中间会用到;结束符，如果几个;放在一起，MySQL只会识别第一个，以后的不会识别，这样会及其不完整

begin

declare v2 int default 123;

select v2;

select @v1;

end//

（上面无法执行，只是参考）

3 视图

3.1 简单视图

视图本质就是一个查询语句

SELECT * FROM t_goods
 WHERE category_id=238
 
 CREATE VIEW v_goods AS
 SELECT * FROM t_goods
 WHERE category_id=238
 
 SELECT * FROM v_goods
DELIMITER $$  设定一个标识符，标识结束$$
 
USE `tedu_store`$$    打开指定数据库tedu_store
 
DROP VIEW IF EXISTS `v_goods238`$$  如果此视图已经存在，就删除
 
CREATE ALGORITHM=UNDEFINED DEFINER=`root`@`localhost` SQL SECURITY DEFINER VIEW `v_goods238` AS
SELECT
  `t_goods`.`id`            AS `id`,
  `t_goods`.`category_id`   AS `category_id`,
  `t_goods`.`item_type`     AS `item_type`,
  `t_goods`.`title`         AS `title`,
  `t_goods`.`sell_point`    AS `sell_point`,
  `t_goods`.`price`         AS `price`,
  `t_goods`.`num`           AS `num`,
  `t_goods`.`barcode`       AS `barcode`,
  `t_goods`.`image`         AS `image`,
  `t_goods`.`status`        AS `status`,
  `t_goods`.`priority`      AS `priority`,
  `t_goods`.`created_time`  AS `created_time`,
  `t_goods`.`modified_time` AS `modified_time`,
  `t_goods`.`created_user`  AS `created_user`,
  `t_goods`.`modified_user` AS `modified_user`
FROM `t_goods`
WHERE (`t_goods`.`category_id` = 238)$$
 
DELIMITER ;

3.1 多级关联视图

 CREATE VIEW v_cat_goods AS
 SELECT c.name,g.item_type,g.title FROM t_goods g
 LEFT JOIN t_goods_category c
 ON g.category_id=c.id
 
 SELECT * FROM v_cat_goods
 
视图在大型项目中被废除！！！！
视图过程是把查询所有的记录都查询回来，然后再过滤数据，过滤掉非238.
如果这张表中有一千万数据。数据量大时无法优化。
Java程序可以吗？mybatis它直接处理，返回结果数据。结果就比视图快。

4 存储过程

存储过程是存储在数据库服务器中的一段过程代码

优点：

Jsp-java-database(proc)

存储过程离数据库最近，所以它执行代码效率最高的。

Client(brower)-WebServer （tomcat）-DatabaseServer（mysql）

WebServer 和 DatabaseServer ，在企业中， WebServer 一般服务器即可，但是 DatabaseServer 是所有服务器中最好的。甚至大型项目，小型机。 Unix+Oracle 。

废除：

写数据库代码（存储过程 - 单独学习语法，无法断点， system.out 没有输出，几乎无法调试。 DBA ），写 java 代码（人员众多，好调试）。后期维护。不好维护。 Java 好维护。
存储过程不好写，质量不好控制。

4.1 定义存储过程

--  修改结束符
delimiter //
 
--  创建存储过程p1
create procedure p1()
begin  --  大括号开始
   -- 定义局部变量v2
   declare v2 int default 123;
   select v2; --  显示v2变量的值
end//  --  大括号结束

4.2 调用存储过程

call p1()//

4.3 查看存储过程

show procedure status\G

所有存储过程

show procedure status where db='db1'\G

查看指定库中的存储过程

show create procedure p1\G

4.4 删除存储过程

drop procedure if exists p1//

4.5 存储过程的参数

三种参数：

in 输入参数
out 输出参数
inout 既能输入又能输出

存储过程参数测试

--  向学生表和联系方式表同时插入数据

--  1) 插入学生数据

--  2) 得到新插入的自增主键值

--  3) 插入联系方式表

传统方式：

页面填写两张表的数据，学生名称，学生的电话，存在两个表中
学生表自增主键
联系表中和学生表的关联（一对一）

CREATE TABLE `t_student` (
`stu_id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(20) DEFAULT NULL,
PRIMARY KEY (`stu_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8


CREATE TABLE `t_tel` (
`stu_id` int(11) NOT NULL,
`tel` varchar(30) DEFAULT NULL,
PRIMARY KEY (`stu_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

DELIMITER //
create procedure p_student_tel
(in name varchar(20),
in tel varchar(20), out id int)
begin
declare v int;-- 定义临时变量用来存自增主键值
--  插入学生数据
insert into t_student(name)
values(name);
--  获得新生成的自增主键值存到v
set v = last_insert_id();
--  插入联系方式数据
insert into t_tel(stu_id,tel)
values(v, tel);
--  自增主键值存到输出参数id
set id=v;
end//


--  调用
CALL p_student_tel('刘强东',13010100808,@id);

select * from t_student;
select * from t_tel;
select @stu_id;

5 流程控制

5.1 if

if 条件 then

代码

end if

if 条件 then

代码 1

else

代码 2

end if

5.2 case

case

when 条件 1 then ...

when 条件 2 then ...

else ...

end case

case 变量或表达式

when 值 1 then ...

when 值 2 then ...

else

end case

分支判断测试

delimiter //
drop procedure if exists p1//
create procedure p1(in v int)
begin
if v=1 then
select 'v的值是1';
end if;
case v
when 2 then select 'v的值是2';
when 3 then select 'v的值是3';
else select 'v的值不是2,3';
end case;
end//
call p1(1) //
call p1(2) //
call p1(3) //
call p1(4) //

5.3 while

while 条件 do

代码

end while

5.4 loop

-- lp: 循环命名，可以起任意的名字

lp: loop

...

if 条件 then

leave lp; -- 指定离开哪个循环

end if;

...

end loop;

5.5 repeat

repeat

代码

until 条件 end repeat;

循环测试

--  新建 tb1 表
use db1 //
drop table if exists tb1 //
create table tb1(
id int primary key auto_increment,
num int
)engine=innodb charset=utf8 //
delimiter //
drop procedure if exists p2//
create procedure p2(in n int)
begin
declare i int default 0;
--  while
while i<n do -- i的值从0递增到n-1
insert into tb1(num) values(i+1);
set i=i+1;
end while; 
--  loop
set i=0;
lp: loop
insert into tb1(num) values(i+1);
set i=i+1;
if i=n then -- i等于n时退出loop循环
leave lp;
end if;
end loop;
--  repeat
set i=0;
repeat
insert into tb1(num) values(i+1);
set i=i+1;
until i=n end repeat; -- i等于n时退出repeat循环
end//
call p2(10) //
select * from tb1 //

6 函数

函数有返回值
调用存储过程用call，调用函数直接调

函数不让？

分布式？又放在java端

Zookeeper集群管理者，当一台服务的配置更新，zk会自动把配置改变信息更新到其它所有的机器上。

6.1 创建函数

create function fn()

returns varchar(100)

begin

执行代码运算产生计算结果

return 计算结果 ;

end//

求平方的函数 fn_pow

DELIMITER //
drop function if exists fn_pow //
create function fn_pow(n int)
returns int -- 函数返回什么类型的数据
begin
declare r int;
set r = n*n;
return r; -- 向调用位置返回计算结果
end //
select fn_pow(5) //
select *, fn_pow(num) from tb1 //

6.2 查看函数

show function status\G

show function status where db='test'\G

show create function fn_pow\G

6.3 删除函数

drop function if exists fn_pow //

7 触发器

对表中的数据操作时，可以触发一段代码执行

三个数据操作：

insert
update
delete

两个触发时间：

before
after

一张表中最多可以有 6 个触发器

before insert
after insert
before update
after update
before delete
after delete

两个隐含对象

新的数据行

insert 的 new ：要插入的新行

update 的 new ：修改后的新行

delete 的 new ：没有

l old

旧的数据行

insert 的 old ：没有

update 的 old ：修改前的旧数据

delete 的 old ：被删除的旧数据

访问新行或旧行数据：

new.id

new.name

old.age

old.tel

7.1 创建触发器

操作商品表insert,before,new

create trigger 名触发时间 on 表

for each row

being

代码

end;

用触发器自动更新updated字段

--  学生表添加 updated字段
alter table t_student
add created datetime //
--  添加触发器，插入数据时自动填入时间
--  before insert
DELIMITER //
CREATE TRIGGER tr_b_i
BEFORE INSERT ON t_student FOR EACH ROW
BEGIN
SET new.created=NOW();
END //
insert into t_student(name)
values('tony') //
select * from t_student //
--  添加触发器，修改数据时自动修改时间
alter table t_student
add updated datetime //
DELIMITER //
CREATE TRIGGER tr_b_u
BEFORE UPDATE ON t_student FOR EACH ROW
BEGIN
SET new.updated = NOW();
END //
UPDATE t_student SET NAME='tina' WHERE stu_id=2
select * from t_student //
--  级联删除，删除主表信息时利用触发器删除子表信息
--  before delete
DELIMITER //
CREATE TRIGGER tr_b_d
BEFORE DELETE ON t_student FOR EACH ROW
BEGIN
DELETE FROM t_tel WHERE stu_id=old.stu_id;
END //
delete from t_student where name='a' //

7.2 查看触发器

进入系统库 information_schema

use information_schema //

查询 triggers 表中触发器信息

select * from triggers\G

7.3 删除触发器

drop trigger 触发器名

级联删除

删除主表的数据时，要先把子表的数据删除。

8 数据库的备份、恢复

备份方式：

冷备份（按月）
热备份

定时任务Job （按周，日（凌晨2点），小时）、
实时备份（主从复制，实时同步）

查看数据安装路径

SELECT @@basedir AS basePath FROM DUAL;

C:\Program Files\MySQL\MySQL Server 5.5\bin>

使用 mysqldump 命令备份数据库

使用 mysql 命令恢复数据库

8.1 备份

退出 mysql ，在系统命令行执行：

下面命令是一行代码，不能折行

mysqldump -uroot -p

--default-character-set=utf8 // 表中存的是什么编码

hr>d:\hr.sql // 库 > 文件

数据库名

8.2 恢复

两步恢复：

1) 在数据库中新建一个库

create database jtdb2 charset utf8;

2) 在系统命令行执行恢复命令

下面命令是一行代码，不能折行

mysql -uroot -p

--default-character-set=utf8

jtdb2<d:\jtds.sql

9 索引

9.1 存储过程产生大量数据

1)  创建一个内存表tm， engine=memory
2)  创建一个磁盘表td
3)  在存储过程中，循环20000次向内存表插入随机字符串
4)  把20000条数据，一批存入磁盘表
5)  清空内存表
--  内存表
drop table if exists tm;
create table tm(
c varchar(20)
) engine=memory charset=utf8;
--  磁盘表
drop table if exists td;
create table td(
id int primary key auto_increment,
c varchar(20)
) engine=innodb charset=utf8;
--  存储过程
DROP PROCEDURE IF EXISTS gen_data;
DELIMITER //
CREATE PROCEDURE gen_data(IN n INT)
BEGIN
DECLARE i INT DEFAULT 0;
WHILE i<n DO
INSERT INTO tm VALUES (UUID());
SET i=i+1;
END WHILE;
INSERT INTO td(c) SELECT c FROM tm;
DELETE FROM tm;
END //
CALL gen_data(1000) 
DROP PROCEDURE IF EXISTS test_insert;
DELIMITER //
CREATE PROCEDURE test_insert(cnt INT)
BEGIN
DECLARE i INT DEFAULT 0;
START TRANSACTION;
WHILE i<cnt
DO
INSERT INTO td(c) VALUES(UUID());
SET i=i+1;
END WHILE;
COMMIT;
END //

9.2 索引优化

索引其本质是创建了一张索引表，现有表的拷贝

（索引需要代价，插入数据要重写排序）

只拷贝现有表的指定索引字段。重要是做了一件事情：

排序

为什么它要排序呢？为什么排序后就快了呢？

不创建索引，查询时，全表遍历。

折半算法

用索引提高数据查找效率

--  没有索引，花3.5秒查询
select * from td where c='ab' //

--  对c字段创建索引，花1分40秒左右
create index td_c_index on td(c) //

--  有索引查询花费 0.00 秒
select * from td where c='ab' //

9.3 MySQL验证索引的使用-最左前缀特性

复合索引

通过EXPLAIN关键字可以判断查询SQL语句是否使用索引

Possible_keys 如果有值就代表使用了哪个索引，如果null就代表查询没有使用索引，全表遍历。

SELECT * FROM tb1

WHERE user_id=100;

SELECT * FROM tb1

WHERE order_id=300;

SELECT * FROM tb1

WHERE user_id=100 AND order_id=300;

SELECT * FROM tb1

WHERE order_id=300 AND user_id=100 ;

没使用索引

EXPLAIN

SELECT * FROM t_goods

WHERE title LIKE '% 皮面 %'

使用索引

EXPLAIN

SELECT * FROM t_goods

WHERE title LIKE ' 皮面 %'

没有使用索引

EXPLAIN

SELECT * FROM t_goods

WHERE title LIKE '% 皮面 '

EXPLAIN SELECT * FROM tb_cart WHERE user_id=1 AND item_id=1

EXPLAIN SELECT * FROM tb_cart WHERE user_id=1

EXPLAIN SELECT * FROM tb_cart WHERE item_id=1

查看SQL的执行计划，可以看出第一句、第二句SQL使用了索引，第三句 SQL未使用索引。很好的证明了索引左侧前缀特性。

注意：

1）下面的语句违反了左侧前缀的特性，为何仍然可以使用索引呢？因为MYSQL对SQL语句有优化，它会重新组合where条件。

EXPLAIN SELECT * FROM tb_cart WHERE item_id=1 AND user_id=1

2）没有where条件的查询是不会使用索引的。

10 作业

商品表 tb_item

有什么品牌

最贵商品的品牌、名称、价格

分页查看商品

商品名和商品描述

商品分类表 tb_item_cat

查询所有的顶层分类

查询 161 下的二层分类

查询 162 下的三层分类

用户表

订单表

订单编号是 20161001490698615071

查询没中类别的商品数量

查询类别 163 的商品

查询商品价格不大于 100 的商品名称列表

查询品牌是联想 , 且价格在 40000 以上的商品名称和价格

查询品牌是三木 , 或价格在 10 以上的商品名称和价格

查询品牌是三木、广博、齐心的商品名称和价格

查询品牌不是联想、戴尔的商品名称和价格

查找品牌是联想且价格大于 10000 的电脑名称

查询联想或戴尔的电脑名称列表

查询联想、戴尔、三木的商品名称列表

查询不是戴尔的电脑名称列表

查询所有是记事本的商品品牌、名称和价格

查询品牌是末尾字符是 ' 力 ' 的商品的品牌、名称和价格

名称中有联想字样的商品名称

查询卖点含有 ' 爆款 ' 电脑名称

查询开头字母是 A 的电脑名称

将地址表中的城市、地区、详细地址组合到一起 ,

获取订单编号为 20161001490698615071 中的每种商品的标题、单价、数量、总价

统计商品表中各个品牌的商品数量

统计商品表中各个品牌的商品数量 , 并且按照数量从少到多排序

统计商品表中各个品牌的商品数量 , 去除品牌为 NULL 的行 , 并且按照数量从少到多排序

查询不同品牌中最贵的商品价格

将不同品牌中最贵的商品按照价格降序排序

找出不同品牌中最贵的商品的前三名

查询订购了 10000028 商品的客户姓名和联系方式 ( 三层子查询 )

首先查询订单表 , 根据 10000028 这个商品编号找到有该商品的订单编号

然后查询订单表 , 根据上面得到的订单编号找到订购此订单的用户编号

最后查询用户表 , 根据第二部中查到的用户编号 , 找到对应的用户名和联系方式

---------------------------------------------------------------------------------------------------------------------------------

查询没中类别的商品数量

select cid,count(*) from tb_item group by cid

查询类别 163 的商品

select id,title,price from tb_item where cid=163;

查询商品价格不大于 100 的商品名称列表

select id,title,price from tb_item where price<100;

查询品牌是联想 , 且价格在 40000 以上的商品名称和价格

select id,title,price from tb_item where brand=' 联想 ' and price>40000;

查询品牌是三木 , 或价格在 50 以下的商品名称和价格

select id,brand,title,price from tb_item where brand=' 三木 ' or price<50;

查询品牌是三木、广博、齐心的商品名称和价格

select id,brand,title,price from tb_item where brand in(' 三木 ',' 广博 ',' 齐心 ');

查询品牌不是联想、戴尔的商品名称和价格

select id,brand,title,price from tb_item where brand not in(' 联想 ',' 戴尔 ');

查找品牌是联想且价格大于 10000 的电脑名称

select id,brand,title,price from tb_item where brand=' 联想 ' and price>10000;

查询联想或戴尔的电脑名称列表

select id,brand,title,price from tb_item where brand=' 联想 ' or brand=' 戴尔 ';

查询联想、戴尔、三木的商品名称列表

select id,brand,title,price from tb_item where brand in(' 联想 ',' 戴尔 ',' 三木 ');

查询不是戴尔的电脑名称列表

select id,brand,title,price from tb_item where brand<>' 戴尔 ';

查询所有是记事本的商品品牌、名称和价格

select id,brand,title,price from tb_item where title like '% 记事本 %';

查询品牌是末尾字符是 ' 力 ' 的商品的品牌、名称和价格

select id,brand,title,price from tb_item where brand like '% 力 ';

名称中有联想字样的商品名称

select id,brand,title,price from tb_item where title like '% 联想 %';

查询卖点含有 ' 爆款 ' 电脑名称

select id,brand,title,price from tb_item where cell_point like '% 爆款 %';

查询开头字母是 A 的电脑名称

select id,brand,title,price from tb_item where title like 'A%';

将地址表中的城市、地区、详细地址组合到一起 ,

select concat(receiver_city, receiver_district,receiver_address) addr from tb_address;

获取订单编号为 20161001490698615071 中的每种商品的标题、单价、数量、总价

select title,price,num,total_fee from tb_order_item where order_id='20161001490698615071';

统计商品表中各个品牌的商品数量

select brand,count(*) from tb_item group by brand;

统计商品表中各个品牌的商品数量 , 并且按照数量从少到多排序

select brand,count(*) c from tb_item group by brand order by c;

统计商品表中各个品牌的商品数量 , 去除品牌为 NULL 的行 , 并且按照数量从少到多排序

select brand,count(*) c from tb_item where brand is not null group by brand order by c;

查询不同品牌中最贵的商品价格

select id,title,brand,price from tb_item where (brand,price) in(

select brand,max(price) m from tb_item where brand is not null group by brand);

将不同品牌中最贵的商品按照价格降序排序

select id,title,brand,price from tb_item where (brand,price) in(

select brand,max(price) m from tb_item where brand is not null group by brand)

order by price desc;

找出不同品牌中最贵的商品的前三名

select id,title,brand,price from tb_item where (brand,price) in(

select brand,max(price) m from tb_item where brand is not null group by brand)

order by price desc

limit 3;

查询订购了 10000028 商品的客户姓名和联系方式

首先查询订单表 , 根据 10000028 这个商品编号找到有该商品的订单编号

然后查询订单表 , 根据上面得到的订单编号找到订购此订单的用户编号

最后查询用户表 , 根据第二部中查到的用户编号 , 找到对应的用户名和联系方式

--  没有索引，花3.5秒查询
select * from td where c='ab' //
--  对c字段创建索引，花1分40秒左右
create index td_c_index on td(c) //
--  有索引查询花费 0.00 秒
select * from td where c='ab' //  select id, username, phone, email from tb_user where id in
(select user_id from tb_order where order_id in
(select order_id from tb_order_item where item_id=10000028))
select
distinct u.id, u.username, u.phone, u.email
from
tb_user u join tb_order o on u.id=o.user_id
join tb_order_item i on o.order_id=i.order_id
where
i.                     item_id=10000028

商品表 tb_item

select * from tb_item;

有什么品牌

select distinct brand from tb_item;

最贵商品的品牌、名称、价格

select brand,title,price
from tb_item
order by price desc
limit 1;

分页查看商品

select id,brand,title,price
from tb_item
order by price desc
-- limit 0,10;
-- limit 10,10;
-- limit 20,10;
limit 30,10;

商品名和商品描述

select
title,item_desc
from
tb_item i join tb_item_desc d
on i.id=d.item_id
limit 1;

商品分类表 tb_item_cat

select * from tb_item_cat;
select * from tb_item_cat
where name like '%电脑%' or
name like '%笔记本%' or
name like '%手机%';

查询所有的顶层分类

select * from tb_item_cat
where is_parent=1 and parent_id is null;

`` 查询 161 下的二层分类

select * from tb_item_cat
where parent_id=161 order by sort_order;

查询 162 下的三层分类

select * from tb_item_cat
where parent_id=162 order by sort_order;

用户表

 select * from tb_user;

订单表

select * from tb_order;
用户 id 是14的订单
select * from tb_order where user_id=14;

订单编号是 20161001490698615071

查询这个订单的所有商品

select * from tb_order_item
where order_id=20161001490698615071;

2－笔记

在实际开发中

jar包的版本是不是随便升级，显然不是。

软件团队中有一个灵魂人物，来决定jar引用哪些，

jar的版本。架构师。

ts-parent pom.xml会看即可，一般由团队资深架构师来搭建。

ts-common 把分散在各个子系统中的工具类。

高级程序员，核心代码编写。一般程序员会用。

ts-manage 聚合工程，小组的高级、中级程序员他来搭建聚合工程，包括聚合工程下的子项目。

ts-manage-pojo User.pojo，照猫画虎写其它模块

ts-manage-mapper

ts-manage-service

ts-manage-controller/web

Maven增强

项目间关系：依赖、继承、聚合

1）依赖，调用jar时，maven会自动去找这个jar依赖的相关的其它的jar包。例如：springmvc3.2.8，自动去找log4j 3.10。通过每个jar提供*.pom文件去找对应依赖

2）继承，jar管理，所有子项目中共有jar包，在此声明，版本升级就非常的方便。

3）聚合，在pom.xml中有一组module，管理多个子项目，一键编译。

测试（工作量非常大）和运维（部署）

2017年美国博士DevOpts开发运维一体化

Maven+GitHub版本控制+Jenkins

自动测试 JUnit @Test，会自动产生一个测试报告

自动运维自动从GitHub下载新的代码，自动的编译，自动打包，自动部署到tomcat下，自动启动

ecshop网上开源商城代码，小型电商。

mysql增强？

在传统企业中由DBA数据库管理员，

写SQL，查询性能调优。

但是让大家只是了解？随着硬件和互联网，大数据的发展。例如：nosql 不仅仅是sql

关系型数据库：Oracle，SqlServer，MySQL

软肋，表的数据的关联关系非常的密切，多表联查，随着数据的增长，查询越来越慢。

数据量有一定限制！

Oracle单表可以支持到多少条数据？上亿

MySQL 1000万

nosql，最低亿级数据以上，mongodb,hbase

MySQL旧的方式在新的形势下被淘汰：

1）视图

2）存储过程，函数

3）触发器

旧的传统的企业，旧的系统还在使用这些旧的技术

我们面试时，会被问。

练习下面两个视图：

============================================

CREATE VIEW v_goods238 AS
SELECT * FROM t_goods WHERE category_id=238

CREATE VIEW v_cat_goods AS
SELECT c.name,g.item_type,g.title FROM t_goods_category c
LEFT JOIN t_goods g
ON c.id=g.category_id

mysql增强，大型系统

1、【废除】视图，本质就是一个查询语句，作用把复杂SQL封装起来，调用中直接访问视图名称即可。这样调用者就非常方便。很难SQL就是DBA，系统分析师。

2、【废除】存储过程，本质脚本语言（弱）。性能高（在数据库上直接执行，它的服务器性能是所有服务器中最强）

数据库迁移oracle,mysql

3、【废除】函数，本质自定义函数，丰富业务算法（个性）。

数据库迁移oracle,mysql

4、【废除】触发器，本质类似拦截器。也很死板。

数据库迁移oracle,mysql

5、索引，复合索引，最左前缀特性

本质，就是提高查询效率

什么时候创建索引？用户抱怨时。

什么字段上创建索引？where,order

主键有索引吗？主键天生就有索引！！！！

文件已上传点主页寻找

day03-1－课堂笔记

创建系统的结构图

选择组织机构的结构模板

小图标，全览

表设计

创建物理数据模型PDM，必须选择数据库类型，因为将来表可以自动生成建表的SQL语句。

Pd会自动产生创建表的sql语句

面试时怎么讲述项目？

你开发过什么项目？
你在开发团队中岗位是什么？负责业务模块是哪些？讲讲这些业务模块？
你未来职业规划？

美发管理系统

我做过美发管理系统，它是全国美发连锁的店的管理系统。这个系统是用来管理全国美发的各个店，包括：前台营业、会员管理、自助平台、服务与商品、库存管理、营业统计分析，还包括系统权限管理。
我是初级程序员，我负责库存管理和权限管理。库存管理主要管理美发相关产品，包括：产品入库、产品出库、库存盘点、库存的调拨、库存统计。
你做的库存盘点是什么意思？我做的库存盘点是指每天晚上打烊之前美发店会对产品进行人工的清点，然后和库存的系统比较。（把盘点的数据录入，只把异常信息录入），产生一张盘点表。上报到系统中。
你做的库存的调拨是什么意思？我做的库存调拨，当某个店产品不够用，这时又来不及从总店（物流）采购赶不上。这时看看其他的门店中有没有多余的产品。如果有，在咱们系统中下一个调拨单。从对方的门店申请调拨多个某产品过来。对方门店确认调拨单，把此产品就从他的门店的库存中减去。然后我们门店去他们门店取这些产品。调拨单如果很多，说明门店产品分配不够合理，提醒客户领导，他重新分配资源。根据往期数据可以进行更好的资源分配。

我在2018年在达内公司时开发了快乐运动健身系统，这个系统包括：数据魔方、预约签到、会员管理、课程管理、员工设置、场馆设置、统计报表、系统设置。

我在里面做了课程管理和系统设置。

我做的课程管理包括：团课、私教、评价系统这3个内容。团体来包场，一次20人作用，小班10人作用。包括所在场馆，是哪个教练，使用场地和课程的内容。

我们做这家健身俱乐部，他私教很多，有很多人定制私教课程。有私教管理。私教包括每个私教所能上的课程，包括所在场馆，场地，私教上课时间和预约人数。

你系统设置做了什么呢？权限管理，实现部门、用户、角色权限分配系统。让每个用户登录只能操作自己权限范围内的事情。限定哪些主菜单可以操作，哪些主菜单不可以操作。哪些模块的按钮能操作，哪些不能操作，例如：只能有新建的权利，不能有删除的权利。

Redis程序使用它？

Jedis 访问redis java api

Redis-server & //后台运行

防火墙要关闭

ts-parent的pom.xml加上jedis依赖

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.6.0</version>
</dependency>

编写测试类

package jedis;
import org.junit.Test;
import redis.clients.jedis.Jedis;
public class TestJedis {
@Test
public void jedis(){
//连接redis服务器，ip+port
String ip = "192.168.27.113";
//获取到jedis对象
Jedis jedis = new Jedis(ip, 6379);
//调用redis set，key=name，value=tony
//jedis.set("name", "tony");
System.out.println(jedis.get("name"));
}
}

package jedis;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
public class TestJedis {
@Test
public void jedis(){
//连接redis服务器，ip+port
String ip = "192.168.27.113";
//获取到jedis对象
Jedis jedis = new Jedis(ip, 6379);
//调用redis set，key=name，value=tony
//jedis.set("name", "tony");
System.out.println(jedis.get("name"));
}
@Test        //分片Shard池化
public void sharded(){
//创建一个Sharded池配置对象
JedisPoolConfig config = new JedisPoolConfig();
//最大的连接数
config.setMaxTotal(50);

//连接多个redis节点，ip和port的信息
List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
//一个的节点信息就ok
JedisShardInfo info1 =
new JedisShardInfo("192.168.27.113",6379);
shards.add(info1);
//创建分片池
ShardedJedisPool pool =
new ShardedJedisPool(config, shards);
//从池中获取一个jedis链接
ShardedJedis jedis = pool.getResource();
System.out.println(jedis.get("name"));
}
}

把jedis和spring框架整合

通过xml配置把jedis的对象创建交给spring框架。

在哪里使用缓存？

package cn.tedu.store.service;
import java.io.IOException;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import cn.tedu.store.bean.dict.Area;
import cn.tedu.store.bean.dict.City;
import cn.tedu.store.bean.dict.Province;
import cn.tedu.store.mapper.DictMapper;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
@Service("dictService")
public class DictServiceImpl implements DictService {
@Resource
private DictMapper dictMapper;
//获取spring框架创建的jedis对象
@Resource
private ShardedJedisPool shardedJedisPool;
//转换对象到json或者json到java对象工具类
private static final ObjectMapper MAPPER = new ObjectMapper();
public List<Province> getProvinceList() {
return dictMapper.getProvinceList();
}
public List<City> getCityList(String provinceCode){
List<City> cityList = null;
//设置redis key的规则
String KEY = "TS_CITY_"+provinceCode;
//由池中获取jedis对象
ShardedJedis jedis = shardedJedisPool.getResource();
//1.从redis中获取数据，如果有数据直接返回
//注意set设置2次就会被覆盖
if(jedis.exists(KEY)){   //判断key是否存在
String json = jedis.get(KEY);
JsonNode jsonNode;
try {
//从缓存中获取数据，然后把json转成java对象，然后直接返回，无需访问数据库
jsonNode = MAPPER.readTree(json);
Object obj = MAPPER.readValue(jsonNode.traverse(),
MAPPER.getTypeFactory().constructCollectionType(List.class, City.class));
return (List<City>) obj;      //减轻数据库访问压力
} catch (Exception e) {
e.printStackTrace();
}
}else{
//传统方式直接从数据库读取数据
cityList = dictMapper.getCityList(provinceCode);
//2.第一访问时redis没有值，必须从数据库中获取值后，把值放入redis
//把java list集合转成字符串json
try {
String json = MAPPER.writeValueAsString(cityList);
jedis.set(KEY, json);
return cityList;
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
public List<Area> getAreaList(String cityCode) {
return dictMapper.getAreaList(cityCode);
}
public String getProvinceNameByCode(String provinceCode) {
return dictMapper.getProvinceNameByCode(provinceCode);
}
public String getCityNameByCode(String cityCode) {
return dictMapper.getCityNameByCode(cityCode);
}
public String getAreaNameByCode(String areaCode) {
return dictMapper.getAreaNameByCode(areaCode);
}
}

Redis缓存应用注意点：

是不是所有的数据都能放在缓存中？

Reids能否替代mysql

当然不是，

缓存是存放热点数据，不会频繁修改的数据！！

内存掉电会有什么问题？

数据丢失。Redis每秒钟会自动存盘c++。MemCache

2-课堂笔记

目标：分析两个项目

两个项目界面原型

大家面试时能讲出业务需求。

业务需求包括：

1）项目（系统）结构图，系统中有哪些业务模块

2）描述清楚每个业务模块它的作用

如果要开发

3）表设计（概要设计）

4）详细设计

5）开发，写代码

6）测试

7）试运行（客户实际环境，没有正式运行，小范围测试8）正式上线

9）维护期

需求分析：

1）和客户“聊天”，派系统分析师+产品经理，调研，结果：《需求调研报告》

2）页面静态原型（静态网站）

美发店管理系统

day10\SalonMS\WebContent\index.html

快乐运动，健身系统

day10\yd\index.html

作者：Darren

QQ：603026148

以上内容归靳烨所有，如果有什么错误或者不足的地方请联系我，希望我们共同进步。

从码农到码到成功

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
jy-16-T-STORE——陈子枢总结

目录：1、day01——1-基础环境;2-介绍;3-Maven的继承和聚合2、day02-01-数据库编程(了解)；2、笔记；2-课堂笔记1、day01——1、基础环境：配置一定要配置jdk的环境下载jdk1.7/jdk1.8 两种jdk，安装版本（windows dll注册表），绿色解压版本D:/java-env/jdk1.7+jdk1.8，很多软件都有配置文件，在配置文件中强行指定JAVA_HOME的路径。Eclipse.ini，相当...
复制链接

扫一扫