麻绳先生

做一些记录性的工作

gradle

基于JVM的构建工具,有一些特性

  • 和maven一样基于约定优于配置的构建框架
  • 强大的多工程构建支持
  • 强大的依赖管理,基于apachelvy
  • 支持已有的maven和ivy仓库
  • 支持传递性依赖管理,不需要远程仓库或pom.xml等配置文件

gradle安装

先决条件

  • gradle需要1.5或更高版本的JDK;
  • gradle自带groovy库,忽略已安装grooy

配置环境变量

  • 将GRADLE_HOME/bin添加到PATH变量中
  • 使用命令gradle -v命令测试

构建基础

task

project

groovy中的闭包

就是一段代码块,在gradle中,主要将闭包作为参数使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//定义一个闭包
def bb = {
println "hello, bb"
}
//定义一个方法,方法的参数是闭包类型
def method(Closure closure){
closure()
}
//调用该方法
method(bb)

//定义一个闭包,带参数
def closure2 = {
v -> println "hello, ${v}"
}

//定义一个需要闭包的方法
def method2(Closure closure){
closure("world")
}

method2(closure2)

拆分

聚合

1
2
3
allproject{

}

maven

目前存在的问题

  1. 一个项目就是一个工程
    如果项目非常庞大,就不适用package来划分模块,最好每一个模块对应一个工程,利于分工协作。借助于maven就可以将一个项目拆分为多个工程。
  2. 项目中需要的jar包需要手动管理
    同样的文件出现在不同的工程中,浪费存储,让文件结构冗余。
  3. jar包来源复杂,难以维护
  4. jar包依赖的其他文件仍需手动管理

什么是maven

是一款服务于java平台的自动化构建工具。

什么是构建

以“java源文件”、“框架配置文件”、JSP、HTML、图片等资源为原材料产生一个可运行的项目的过程。

  • 清理:将之前编译生成的字节码文件删除,为下一次编译做准备
  • 编译:将java源程序编程为class字节码文件
  • 测试:自动测试,自动调用junit程序
  • 报告:测试程序执行的结果
  • 打包:动态web工程war包,java工程jar包
  • 安装:maven特定的概念,将打包得到的文件复制到仓库中指定位置
  • 部署:将动态web工程生成的war包复制到servlet容器的指定目录下

安装maven核心程序

  • 检查JAVA_HOME环境变量
  • 解压maven核心程序压缩包,英文无空格目录
  • 配置maven相关环境变量
    • MAVEN_HOME或M2_HOME(bin目录上一级)
    • path(通常带bin目录)
  • 运行mvn -v验证配置

maven核心概念

约定的目录

  • 根目录:工程名
    • 以配置的方式告诉框架自定义文件:classpath:spring-content.xml
  • src目录:存放源码
  • pom.xml:maven工程核心配置文件
  • main目录:存放主程序
  • test目录:存放测试程序
  • java目录:存放java源码
  • resources目录:存放框架或其他工具的配置文件

约定大于配置,配置大于编码

POM

含义:project object model项目对象模型

坐标(gav)

  • groupid:公司组织域名倒序+项目名
  • artifactid:模块名
  • version:版本

依赖

  • 对于自己的maven工程,使用install命令将其安装到仓库。
  • 依赖的范围
    • compile:对主程序有效,对测试程序有效,参与打包
    • test:对主程序无效,对测试程序有效,不参与打包
    • provided:对主程序有效,对测试程序有效,不参与打包,不参与部署,例如servlet-api.jar
  • scope
  • 只有compile范围的依赖可以传递
  • exclusions用于排除依赖

依赖的原则

  • 作用:解决模块工程之间的jar包冲突
    • 最短路路径优先
    • 路径相同时先声明者优先,指的是dependency标签的声明顺序

统一管理依赖的版本号

  • properties标签,后跟依赖的id
  • 通过${依赖的id}访问版本号
  • 由于test范围的依赖不能传递,所以必然分散在各个模块工程中,导致不一致问题
    • 解决思路:将依赖统一提取到父工程中,在子工程中声明依赖时不指定版本,以父工程中统一的设定为准,方便维护
    1. 创建一个maven工程为父工程,注意打包方式为pom
    2. 在子工程中声明对父工程的引用
    3. 将子工程中的坐标中与父工程坐标中重复的内容删除
    4. 在父工程中统一管理依赖
    5. 子工程中删除依赖的版本号

子工程要首先install父工程

仓库

生命周期/插件/目标

  • 各个构建环节执行的顺序是既定的;
  • maven核心程序中定义了抽象的生命周期;
  • 不论执行哪个命令,maven都会从生命周期最开始的位置执行;

继承

聚合

一键安装各个模块工程
在一个总的聚合工程中配置各个参与聚合的模块

1
2
3
4
5
<modules>
<module></module>
<module></module>
<module></module>
</modules>

常用maven命令

首先进入pom.xml目录

  • mvn clean:清理
  • mvn compile:编译主程序
  • mvn test-compile:编译测试程序
  • mvn test:执行测试
  • mvn package:打包
  • mvn install:安装
  • mvn site:生成站点

自动部署

通过build标签配置当前工程的构建过程中的特殊设置,cargo插件。

spring boot入门

spring简介

简化spring开发流程,J2EE开发的一站式解决方案。

优点

  • 快速创建独立运行spring项目以及与主流框架集成
  • 使用嵌入式servlet容器,应用无需达成war包
  • starters自动依赖与版本控制
  • 大量的自动配置,简化开发,也可以修改默认值
  • 无需配置XML,无代码生成
  • 准生产环境的运行时应用监控
  • 与云计算天然集成

微服务

是一种架构风格,其认为一个应用应该是一组小型服务,可以用过HTTP的方式通信。

每一个功能元素最终都是一个可独立替换和独立升级的软件单元。

环境配置

spring-boot-starter

启动器,spring-boot官方提供了一系列启动器。将所有的功能场景抽取出来,只要在项目里面引入这些starter,相关依赖就会自动导入。

主程序类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
* @SpringBootApplication标注这是spring boot应用
*/
@SpringBootApplication
public class HelloWorldMainApplication {

public static void main(String[] args){
//spring应用启动
SpringApplication.run(HelloWorldMainApplication.class, args);
}
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration//表示这是一个Spring Boot的配置类
@EnableAutoConfiguration//开启自动配置功能
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication

@SpringBootConfiguration:表示这是一个Spring Boot的配置类;
@Configuration:配置类上,表示配置类也是容器中的一个组件@Component

1
2
@AutoConfigurationPackage//自动配置包
@Import(EnableAutoConfigurationImportSelector.class)

spring-boot的注释没事可以看看。

spring的声明式事务控制

基于XML的声明式事务控制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<!--配置步骤-->
<!--配置事务管理器-->
<bean id="tansactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--配置事务的通知,此时需要导入事务的约束-->
<tx:advice id="txAdvice" transaction-manager="transactionManger"></tx:advice>
<!--配置事务的属性
isolation:用于指定事务的隔离等级,默认是DEFAULT,表示使用数据库的默认隔离等级;
propagation:用于指定事务的
-->
<tx:attributes>
<tx:method name="*" propagation="REQUIRED" read-only="false"/></tx:method>
<tx:method name="find*" propagation="SUPPORTS" read-only="true"/></tx:method>
</tx:attributes>
</tx:advice>
<!--配置AOP-->
<!--配置AOP中的通用切入点表达式-->
<!--建立食物通知和切入点表达式的对应关系-->
<!--配置事务的属性,在事物的通知tx:advice标签内-->
<aop:config>
<!--配置切入点表达式-->
<aop:pointcout id="pt1" execution(* com.service.impl.*.*(..))"></aop:pointcut>
<!--建立切入点表达式和事务通知的对应关系-->
<aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
</aop:config>

基于纯注解的声明式事务控制

  1. 配置事务管理器;
  2. 开启spring对注解事务的支持;
    • <tx:annotation-driven transaction-manager=”transactionManager”>
  3. 在需要事物支持的地方使用@Transactional

基于编程式事务控制

不够灵活

spring5新特性

  • 与JDK相关升级;
  • 核心容器更新;
  • JetBrains Kotlin语言支持;
    • 运行于在JVM上,独立语言;
  • 响应式编程风格;
  • Junit5支持;
  • 依赖类库的更新;

spring中的JdbctTemplate

是spring框架中提供的一个对象,是对原始Jdbc API对象的简单封装,spring框架提供了许多操作模板类。

  • 操作关系型数据
    • JdbcTemplate
    • HibernateTemplate
  • 操作nosql数据库
    • RedisTemplate
  • 操作消息队列
    • JmsTemplate

JdbcTemplate作用

和数据库交互的模板类

JdbcTemplate基本用法

首先通过XML文件配置必要信息,这块是spring框架必要的IOC手法;

1
2
3
4
5
6
7
8
9
10
11
<!--配置JdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--配置数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/databasename"></property>
<property name="username" value="username"></property>
<property name="password" value="password"></property>
</bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//获取容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//获取对象
JdbcTemplate jt = ac.getBean("jdbcTemplate", JdbcTemplate.class);
//执行操作
jt.execute("insert into account(name, money) values ('name', 222)");
//保存
jt.update("insert into account(name, money) values (?, ?)", "name", 333);
//更新
jt.update("update account set name=?, money=?, where id=?","test",2345,3);
//删除
jt.update("delete from account where id=?", 3);
//查询所有
List<Account> accounts = jt.query("select * from account where money > ?", new AccountRowMapper(), 1000f);
List<Account> accounts = jt.query("select * from account where money > ?", new BeanPropertyRowMapper<Account>(Account.class), 1000f);
for(Account account : accounts){
System.out.println(account);
}
//查询一个
List<Account> accounts = jt.query("select * from account where id = ?", new BeanPropertyRowMapper<Account>(Account.class), 1);
//查询返回一行一列(使用聚合函数,但是不加group by子句
Long count = jt.queryForObject("select count(*) from account where money > ?", Long.class, 1000f);