发表于

环境

  • 构建工具:Gradle
  • 开发语言:Kotlin
  • mysql版本: 8.0

配置步骤

1.引入依赖

在build,gradle文件引入mybatis-spring-boot-starter-web的依赖：

1
implementation "org.springframework.boot:spring-boot-starter-web:2.4.9"

引入数据库连接依赖：

1
implementation "mysql:mysql-connector-java:8.0.26"

2.引入数据源

application.yml配置文件中引入数据源：

1
2
3
4
5
6
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456
    driver: com.mysql.cj.jdbc.Driver

这样，springboot就可以访问数据了。

3.创建数据库表

建表语句：

1
2
3
4
5
6
7
8
9
10
11
-- create table `account`
# DROP TABLE `account` IF EXISTS
CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL,
  `money` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
INSERT INTO `account` VALUES ('1', 'aaa', '1000');
INSERT INTO `account` VALUES ('2', 'bbb', '1000');
INSERT INTO `account` VALUES ('3', 'ccc', '1000');

4.具体实现

这篇文篇通过注解的形式实现。

5.创建实体：
1
2
3
4
5
data class Account (
    var id:Int = 0,
    var name: String? = null,
    var money :Double= 0.0
)
6.Dao层
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Mapperpublic interface AccountMapper {

    @Insert("insert into account(name, money) values(#{name}, #{money})")
    int add(@Param("name") String name, @Param("money") double money);

    @Update("update account set name = #{name}, money = #{money} where id = #{id}")
    int update(@Param("name") String name, @Param("money") double money, @Param("id") int  id);

    @Delete("delete from account where id = #{id}")
    int delete(int id);

    @Select("select id, name as name, money as money from account where id = #{id}")
    Account findAccount(@Param("id") int id);

    @Select("select id, name as name, money as money from account")
    List<Account> findAccountList();}

7.service层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Mapper
interface AccountMapper {
    @Insert("insert into account(name, money) values(#{name}, #{money})")
    fun add(@Param("name") name: String?, @Param("money") money: Double): Int

    @Update("update account set name = #{name}, money = #{money} where id = #{id}")
    fun update(
        @Param("name") name: String?,
        @Param("money") money: Double,
        @Param("id") id: Int
    ): Int

    @Delete("delete from account where id = #{id}")
    fun delete(id: Int): Int

    @Select("select id, name as name, money as money from account where id = #{id}")
    fun findAccount(@Param("id") id: Int): Account?

    @Select("select id, name as name, money as money from account")
    fun findAccountList(): List<Account?>?
}

8.controller层，构建restful API

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

@CrossOrigin
@RestController
class MainControl {
    

    @Autowired
    lateinit var accountService: AccountService


    @GetMapping(value = ["/list"])
    fun getAccounts(): List<Account> {
        return accountService.findAccountList()
    }

    @GetMapping(value = ["/{id}"])
    fun getAccountById(@PathVariable("id") id: Int): Account? {
        return accountService.findAccount(id)
    }

    @PutMapping(value = ["/{id}"])
    fun updateAccount(
        @PathVariable("id") id: Int, @RequestParam(value = "name", required = true) name: String?,
        @RequestParam(value = "money", required = true) money: Double
    ): String {
        val t = accountService.update(name, money, id)
        return if (t == 1) {
            "success"
        } else {
            "fail"
        }
    }

    @DeleteMapping(value = ["/{id}"])
    fun delete(@PathVariable(value = "id") id: Int): String {
        val t = accountService.delete(id)
        return if (t == 1) {
            "success"
        } else {
            "fail"
        }
    }
}

配置完毕

最后启动程序, 浏览器访问:http://localhost:8080/list进行测试

本文为作者原创 转载时请注明出处 谢谢

img

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

1.增加字段

1
2
ALTER TABLE tableName ADD COLUMN columnName VARCHAR(20) DEFAULT NULL --增加一个字段，默认为空
ALTER TABLE tableName ADD COLUMN columnName VARCHAR(20) NOT NULL     --增加一个字段，默认不能为空

2.删除字段

1
ALTER TABLE tableName DROP COLUMN columnName --删除一个字段

3.修改字段类型

1
ALTER TABLE tableName MODIFY COLUMN columnName VARCHAR(10) --修改一个字段的类型

4.删除主键

1
2
3
4
Declare @Pk varChar(100);
Select @Pk=Name from sysobjects where Parent_Obj=OBJECT_ID('tableName') and xtype='PK';
if @Pk is not null
exec('Alter table tableName Drop '+ @Pk)

5.给已经建好的表字段添加唯一性约束

1
alter table 表名 add unique(字段名);

本文为作者原创 转载时请注明出处 谢谢

img

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

前言

我们都知道Web前端主要由HTML CSS 和JS三部分语言组成, 其中HTML和CSS负责界面, JS负责事件逻辑

任何一个应用, 无非就是界面和事件两大块组成, 本文主要介绍如何快速上手界面的编写

控件对比

Android应用界面的编写主要通过控件的排列组合, 常用的控件有TextView, EditText, ImageView, 那么在Web前端中也有类似于Android中的控件,只不过在前端中不叫控件, 而叫标签, 部分对比如下:

Html标签 Android控件
img标签 ImageView
input标签和textarea标签 EditText
button标签 Button
h系列标签,p标签,span标签 类似于TextView
div标签 类似于水平方向的LinearLayout

容器标签和文本标签以及叶子标签的区别:

  • 容器标签: 里面可以嵌套其他标签, 比如div标签
  • 文本标签: 里面可以填充文本显示, 比如p标签
  • 叶子标签:里面既不可以嵌套标签也不可以嵌套文本, 比如img标签

当然, 有些标签既是容器标签又是文本标签:

标签 容器标签 文本标签 叶子标签
div √ √ ×
p × √ ×
span √ √ ×
h系列 √ √ ×
button √ √ x
img × × √
audio × × √
video × × √

除此之外, 有的标签本身自带换行符:

标签 开头自带换行符 结尾自带换行符
div √ √
h系列 √ √
button x x
p √ ×
ul √ √
span × ×
img × ×
audio × ×
video × ×

关于控件的宽高显示:

样式属性 Android宽高属性
display:block android:layout_width=”match_parent”
display:inline android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
display:inline-block android:layout_width=”自定义”
android:layout_height=”自定义”

关于元素的位置定位:

标签 Android控件
position:absolute
元素的位置以浏览器窗口为参照摆放		 相当于设置成为Framelayout的子控件
position:relative
元素位置以邻近元素为参照摆放		 相当于设置成为LinearLayout的子控件
position:fixed
元素的位置以浏览器窗口为参照摆放, 但是不随滚动条移动		 相当于在ScrollView上层增加一个固定控件
position: sticky
粘性定位, 元素滚动超出页面时切换为fixed模式		 和Android中粘性控件一样
position: static
默认状态,此时top left right bottom等属性均无效

也就是说, top left right bottom这几个属性需要和position配合使用

关于自定义控件(标签)

在Android中除了官方提供的原生控件外, 我们还可以自定义控件, 那么Web前端可以吗?

如果放在以前肯定不行, 只能使用官方提供的html标签, 现在nodejs环境下可以实现自定义标签, 比如vue中:

image-20210806111608395

在Android中我们可以对控件设置相应的属性, 并且把共同的属性抽取到style文件中

那么Web前端也一样, 只不过属性和样式分开处理,抽取出来样式放置在style标签下, 如果单独放到一个文件中, 那么这个文件的后缀必须为.css, 所以我们又称之为CSS样式表 或者CSS语言

事实上, 我们会发现, Android的界面编写方式很多都是参考的Web前端

小练习:

  1. 写一个左侧带图标的文本:

    image-20210806122728724

    只要一个img标签和一个span标签够了:

    1
    <img style="max-width: 26px; max-height: 26px" src="./assets/logo.png"> <span>成墨文档</span>

    效果如下:

    成墨文档

    接下来需要给内容增加一个超链接, 所以在最外层包裹一个a标签

    1
    <a><img style="max-width: 26px; max-height: 26px" src="./assets/logo.png"> <span>成墨文档</span></a>

    效果如下:

    成墨文档

    考虑到这个内容属于网站的网站标题, 为了利于seo 因此最外层再包裹一个h1标签, 此时文本也变大

    1
    2
    3
    4
    5
    <h1>
      <a class="navbar-brand" href="/web/homepage/index">
      <img style="max-width: 26px; max-height: 26px" src="./assets/logo.png"> <span>成墨文档</span>
      </a>
      </h1>

    效果如下:

    成墨文档

  2. 写一个网站导航条:

    image-20210806154307953

    html代码如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    <div  id="navbar">
       
       <h1>
        <a class="navbar-brand" href="/web/homepage/index">
        <img style="max-width: 26px; max-height: 26px" src="./assets/logo.png"> <span>成墨文档</span>
        </a>
        </h1>
          
            <ul >
    <li><a href="/web/homepage/index">首页</a></li>
    <li><a target="_blank" href="https://www.xxx.com/pricing">价格</a></li>
    <li><a href="http://blog.xxx.com/">博客</a></li>
    <li><a href="https://docs.xxx.com/#/">帮助文档</a></li>
    <li><a href="/web/homepage/apidoc">API</a></li>
    <li class="long-li nav-item"><a href="/web/signup/sign_up" id="btn-register">免费注册</a></li>
    <li class="short-li nav-item"><a href="/web/login">登录</a></li>
    </ul>
    </div>

    效果如下:

成墨文档 

<ul >
   <li><a href="/web/homepage/index">首页</a></li>
<li><a target="_blank" href="https://www.xxx.com/pricing">价格</a></li>
<li><a href="http://blog.xxx.com/">博客</a></li>
<li><a href="https://docs.xxx.com/#/">帮助文档</a></li>
<li><a href="/web/homepage/apidoc">API</a></li>
<li class="long-li nav-item"><a href="/web/signup/sign_up" id="btn-register">免费注册</a></li>
<li class="short-li nav-item"><a href="/web/login">登录</a></li>
</ul>

我们需要给其添加相应的样式:

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
29
30
31
32
33
34
35
36
37
38
39
<style >
   #navbar{
 /*固定在顶部*/
   position: fixed;
   top:0px;
   left:0px;
   width:100%;
   height:64px;
   background-color:#AAAAAA;
   padding-left:50px;
   padding-right:20px;
   display:flex;
       align-items:center;/*指定垂直居中*/
   }
ul{

  display: inline-block;
     /*列表向右浮动*/
			float: right;
}
h1{
  display:inline;
}
li{
  /*去除列表中的原点样式*/
  list-style: none; 
  
 
   /*列表从左向右浮动*/
			float: left;
    margin-left: 40px;
} 

a{
  /*取消超链接下划线*/	
  text-decoration: none;

}
</style>

以上是比较基础的练习, 熟悉的差不多了后, 我们开始进入到使用vue的开发阶段

Vue快速上手

环境配置:

vue项目创建:

第一步 安装vue:

1
npm install -g @vue/cli-service-global

第二步 创建脚手架(模板工程)

1
2
3
4
vue create hello-world

#或者直接使用图形化界面创建
vue ui

这里直接使用图形化创建:

image-20210806115245063

创建后自动生成相应的文件和目录, 目录结构如下:

image-20210806115856398

image-20210806162357285

image-20210806170246960

大部分和原生相比差别不大, 但是开发上更加高效,具体参考:

Vue入门基础语法

为什么选择vue

vue只是一个开发框架 或者理解为一个中间人, 它借助于nodejs环境, 使得我们可以采用MVVM的模型, 同时集成第三方各种插件, 方便而又快速地组件化开发, 相比原生而言整体的架构也更加清晰, 后期维护也得心应手

当然, 你也可以使用其他前端框架, 比如Facebook的React框架, 或者Google推出的Angular框架, 未来也可能出现新的框架, 但有一点是不会变的, 不管是什么框架, 它编译出来最终文件还是html css和js, 因为 目前浏览器只识别这三种文件

本文为作者原创 转载时请注明出处 谢谢

img

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

Vue 的模块机制

　　Vue 是通过 webpack 实现的模块化，因此可以使用 import 来引入模块，例如：

img

　　此外，你还可以在 bulid/webpack.base.conf.js文件中修改相关配置：

img

　　意思是，你的模块可以省略 ".js"，".vue"，“.json”后缀，webpack 会在之后自动添加上；可以用 "@"符号代替 "src"字符串等。

　　export 用来导出模块，Vue 的单文件组件通常需要导出一个对象，这个对象是 Vue 实例的选项对象，以便于在其它地方可以使用 import 引入。而 new Vue() 相当于一个构造函数，在入口文件 main.js 构造根组件的同时，如果根组件还包含其它子组件，那么 Vue 会通过引入的选项对象构造其对应的 Vue 实例，最终形成一棵组件树。

　　export和export default的区别在于：export可以导出多个命名模块，例如：

1
2
3
4
5
6
//demo1.js
export const str = 'hello world'

export function f(a){
    return a+1
}

　　对应的引入方式：

1
2
//demo2.js
import { str, f } from 'demo1'

　　export default只能导出一个默认模块，这个模块可以匿名，例如：

1
2
3
4
5
//demo1.js
export default {
    a: 'hello',
    b: 'world'      
}

　　对应的引入方式：

1
2
//demo2.js
import obj from 'demo1'

　　引入的时候可以给这个模块取任意名字，例如 "obj"，且不需要用大括号括起来。

本文转载自:https://www.cnblogs.com/blog-cxj2017522/p/8562536.html

img

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

MVC与MVVM

MVC（Model-View-Controller）：

1
2
3
M指的是从后台获取到的数据， 
V指的是显示动态数据的html页面，
C是指响应用户操作、经过业务逻辑处理后去更新视图的过程，在此过程中会导致对view层的引用。

这里我们发现我们网站的大量代码都被放在Controller，导致Controller代码臃肿；而且不利于单元测试，因为业务逻辑处理和视图更新操作会混杂在一起。

MVVM (Model-View-ViewModel)：
MVVM是MVC的一个衍生模型，这里的 ViewModel 把业务逻辑处理、用户输入验证等跟视图更新操作分离开了。MVVM是数据驱动的，我们只需要关心数据的处理逻辑即可，它会通过模板渲染去单独处理视图的更新而不需要我们亲自去操作Dom元素。

实例化Vue对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<div id="app">
</div>

<script src="js/vue.min.js"></script>
<script>
    //调用Vue的构造函数创建实例对象
    var vm = new Vue({
        //根节点选择器
        el: '#app',
        //数据对象
        data: {
            message: 'hello world',
        },
        //渲染模板
        template: '<div>message: {{ message }}</div>'
    })
</script>

Vue会将渲染模板结合数据对象生成的html结构替换掉根节点，只要数据对象上的message发生改变，插值处的内容就会跟着改变，上述例子的实际效果如下：

1
2
3
<body>
    <div>message: hello world</div>
</body>

模板语法

上面的双大括号绑定是vue最常用的数据绑定方式，除了双大括号还可以使用v-text属性进行绑定

1
<div>message: <span v-text="message"></span></div>

如果要绑定html结构的话，需要使用到v-html指令，否则vue会把这段html代码看成字符串直接绑定到对应位置

1
2
3
4
5
6
7
8
new Vue({
    el: '#app',
    data:{
        message: 'hello world',
        html: '<span>hello world</span>'
    },
    template: '<div>message: <span v-html="html"></span></div>'
})

需要绑定html元素特性的时候需要使用v-bind指令，v-bind可以省略

1
2
<div v-bind:id="id"></div>
<div :id="id"></div>

双大括号的插值方法还可以使用js表达式，这些表达式会在所属 Vue 实例的数据作用域下被解析

1
2
3
4
5
6
7
{{ number + 1 }}

{{ boolean ? 'true' : 'false' }}

{{ message.split('').reverse().join('') }}

<div :id="'is' + id"></div>

注意，这里的javascript语句只能是单个表达式，其他的声明变量、流程控制语法都不会生效

事件绑定

除了数据绑定外，vue还帮我们优化了事件绑定流程，指令为v-on，可缩写为@，后面是事件名称

1
2
3
<a v-on:click="console.log(1)">打印1</a>

<a @click="console.log(1)">打印1</a>

仅仅一句js表达式是不够支撑我们的日常开发的，所以vue给我们提供了自定义事件处理方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
new Vue({
    el: '#app',
    data: {
        message: 'hello world'
    },
    //log为methods中定义的函数名，vue会默认把原生DOM事件对象当做参数传到处理函数中
    template: '<a @click="log">Click Me</a>',
    methods: {
        log: function(event){
            console.log(this.message);
            event.stopPropagation();
        }
    }
});

除了直接绑定到一个方法，也可以在内联 JavaScript 语句中调用方法

1
2
<!-- 使用内联语法后，原生DOM对象需要手动传入(变量名变更为 $event ) -->
<a @click="log(1, $event)">Click Me</a>

计算属性 computed

模板内的表达式非常便利，但是设计它们的初衷是用于简单运算的。在模板中放入太多的逻辑会让模板过重且难以维护。例如这个字符串反转：

1
<div>{{ message.split('').reverse().join('') }}</div>

这种情况我们可以用 computed 解决

1
2
3
4
5
6
7
8
9
10
11
12
new Vue({
    el: '#app',
    data: {
        message: 'hello'
    },
    template: '<div>{{ reversedMessage }}</div>', //olleh
    computed: {
        reversedMessage: function(){
            return this.message.split('').reverse().join('');
        }
    }
});

这里看渲染模板就直观多了

监听属性 watch

Vue 提供了 watch 这种通用的方式来观察和响应 Vue 实例上的数据变动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<div id="app">
    <p>问题: <input v-model="question"></p>
    <p>{{ answer }}</p>
</div>

<script src="js/vue.min.js"></script>
<script>
    var vm = new Vue({
        el: '#app',
        data: {
            question: '',
            answer: '请先输入问题',
            timer: undefined,
        },
        watch: {
            question: function(newVal, oldVal){
                if(this.timer){ clearTimeout(this.timer); }
                var _this = this;
                this.answer = '等待停止输入...';
                setTimeout(function(){ _this.answer = 'Yes!!!'; }, 1000);
            }
        }
    });
</script>

表单绑定，指令为 v-model

v-model 指令在表单 及 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<div id="app">
    <input v-model="message" placeholder="写点什么。。">
    <!-- 通过v-model绑定message后,
        在input输入的文字会实时更新到数据对象上,
        从而自动渲染在下面的p标签上
    -->
    <p>Message: {{ message }}</p>
</div>

<script src="js/vue.min.js"></script>
<script>
    var vm = new Vue({
        el: '#app',
        data: {
            message: ''
        }
    })
</script>

单个复选框

1
2
3
4
<input type="checkbox" id="checkbox" v-model="checked">
<label for="checkbox">{{ checked }}</label>

data: { checked: true }

多个复选框的情况下，把v-model绑定到同一个数组即可:

1
2
3
4
5
6
<input type="checkbox" value="blue" id="blue" v-model="checkedColor"/>
<label for="blue">blue</label>
<input type="checkbox" value="red" id="red" v-model="checkedColor"/>
<label for="red">red</label>

data: { checkedColor: [] }

单选按钮

1
2
3
4
5
6
<input type="checkbox" value="true" id="true" v-model="checkedRadio"/>
<label for="true">true</label>
<input type="checkbox" value="false" id="false" v-model="checkedRadio"/>
<label for="false">false</label>

data: { checkedRadio: '' }

条件渲染

在javascript语法中有if-else等流程语句让程序执行不同的代码块，在vue中同样有 v-if、v-else-if、v-else 这些指令控制某些节点的显示与否

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<div id="app">
    <div v-if="isShow">
        <label>用户名</label>
        <input type="text" placeholder="请输入用户名" />
    </div>
    <!-- v-else 元素必须紧跟在带 v-if 或者 v-else-if 的元素的后面，否则它将不会被识别。 -->
    <div v-else>
        <label>邮箱</label>
        <input type="text" placeholder="请输入邮箱" />
    </div>
    <button @click="switchDom">切换输入框类型</button>
</div>

<script src="js/vue.min.js"></script>
<script>
    var vm = new Vue({
        el: '#app',
        data: { isShow: true },
        methods: {
            switchDom: function(){ this.isShow = !this.isShow; }
        }
    })
</script>

在上述例子中，我们点击 button 会显示不同的dom，但是如果我们在input里面输入文字再进行切换的时候会发现，输入的文字并不会被清除，这是因为vue的 就地复用 策略导致的。vue为了尽可能高效地渲染dom元素，通常会复用已有元素而不是从头开始渲染，如果不想vue复用这些元素，我们可以添加一个具有唯一值的 key 属性

1
2
3
<input type="text" placeholder="请输入用户" key="username"/>

<input type="text" placeholder="请输入邮箱" key="email"/>

另一个用于根据条件展示元素的选项是 v-show 指令。用法大致一样：

1
<p v-show="show">Hello!</p>

v-if 与 v-show 区别：
v-if 是惰性渲染，在初始渲染时条件为假，什么也不做——直到条件第一次变为真时，才会开始渲染条件块；在切换过程中条件块内的事件监听器和子组件会被销毁和重建。
v-show 不管初始条件是什么，元素总会被渲染，切换的只是css的display属性

列表渲染

我们用 v-for 指令根据一组数据表进行列表渲染。v-for 指令需要使用 item in list 的语法，list指的是原数据数组，item指的是迭代的数组元素。v-for 指令还支持一个可选的表示当前迭代元素索引的第二个参数 (item, index) in list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<div id="app">
    <ul>
        <li v-for="item in list">
        <!-- 效果一样 -->
        <!-- <li v-for="item of list"> -->
            {{ item.text }}
        </li>
    </ul>
</div>

<script src="js/vue.min.js"></script>
<script>
    var vm = new Vue({
        el: '#app',
        data: {
            list: [
                {text: 'blue'},
                {text: 'red'},
                {text: 'yellow'},
            ]
        }
    })
</script>

除了数组，v-for指令还可以通过一个对象的属性来迭代，v-for 指令最多可以支持3个参数，第二第三个可选。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<li v-for="(value, key, index) in object">
    {{ index }}. {{ key }}: {{ value }}
</li>

data:{
    object: {
        firstName: 'John',
        lastName: 'Doe',
        age: 26
    }
}

//结果
0. firstName: John
1. lastName: Doe
2. age: 26

Vue的生命周期

图片描述

根据上图做了一个测试例子，列出了每个生命周期对应的不同属性的状态

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<div id="app">
    {{message}}
</div>

<script src="js/vue.min.js"></script>
<script>
    var vm = new Vue({
        el: '#app',
        data: {
            message : "hello"
        },
        beforeCreate: function () {
            console.group('beforeCreate 创建前状态===============》');
            console.log("%c%s", "color:red" , "el     : " + this.$el); //undefined
            console.log("%c%s", "color:red","data   : " + this.$data); //undefined
            console.log("%c%s", "color:red","message: " + this.message)
        },
        created: function () {
            console.group('created 创建完毕状态===============》');
            console.log("%c%s", "color:red","el     : " + this.$el); //undefined
            console.log("%c%s", "color:red","data   : " + this.$data); //已被初始化
            console.log("%c%s", "color:red","message: " + this.message); //已被初始化
        },
        beforeMount: function () {
            console.group('beforeMount 挂载前状态===============》');
            console.log("%c%s", "color:red","el     : " + (this.$el)); //已被初始化
            console.log(this.$el);
            console.log("%c%s", "color:red","data   : " + this.$data); //已被初始化
            console.log("%c%s", "color:red","message: " + this.message); //已被初始化
        },
        mounted: function () {
            console.group('mounted 挂载结束状态===============》');
            console.log("%c%s", "color:red","el     : " + this.$el); //已被初始化
            console.log(this.$el);
            console.log("%c%s", "color:red","data   : " + this.$data); //已被初始化
            console.log("%c%s", "color:red","message: " + this.message); //已被初始化

            var _this = this;
            setTimeout(function(){
                _this.message = 'hello world!!';
            }, 3000);
        },
        beforeUpdate: function () {
            console.group('beforeUpdate 更新前状态===============》');
            console.log("%c%s", "color:red","el     : " + this.$el);
            console.log(this.$el);
            console.log("%c%s", "color:red","data   : " + this.$data);
            console.log("%c%s", "color:red","message: " + this.message);
        },
        updated: function () {
            console.group('updated 更新完成状态===============》');
            console.log("%c%s", "color:red","el     : " + this.$el);
            console.log(this.$el);
            console.log("%c%s", "color:red","data   : " + this.$data);
            console.log("%c%s", "color:red","message: " + this.message);
        },
        beforeDestroy: function () {
            console.group('beforeDestroy 销毁前状态===============》');
            console.log("%c%s", "color:red","el     : " + this.$el);
            console.log(this.$el);
            console.log("%c%s", "color:red","data   : " + this.$data);
            console.log("%c%s", "color:red","message: " + this.message);
        },
        destroyed: function () {
            console.group('destroyed 销毁完成状态===============》');
            console.log("%c%s", "color:red","el     : " + this.$el);
            console.log(this.$el);
            console.log("%c%s", "color:red","data   : " + this.$data);
            console.log("%c%s", "color:red","message: " + this.message)
        }
    })
</script>

本文转载自:https://segmentfault.com/a/1190000015209557

img

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

前言

划水摸鱼老司机的你, 是否时常感觉一块屏幕不够用, 这里给大家推荐几款扩展屏幕软件, 方便大家把充分利用手中的闲置设备

毕竟 不用就是浪费

工具

  • Spacedesk：主机端目前只支持Windows,扩展端支持IOS,Android和PC,甚至一个有html5浏览器的设备都可以, 支持WIFI连接。

  • Air Display : 主机端支持Mac和Windows,扩展端支持全平台

    以下是扩展端应用下载链接:

    iOS: Get Air Display 3 from the App Store

    macOS: Get Air Display for Mac from the Mac App Store

    Android: Get Air Display 2 from Google Play

    Windows: Get Air Display for Windows from avatron.com

以下是Mac版宿主应用下载链接(Windows版自行百度):

Download Air Display Host

  • IDisplay: 主机端支持Mac和Windows,扩展端支持全平台, 支持WIFI连接

  • YamDisplay: 支持mac和ipad扩展, 有免费7分钟试用版, 每隔七分钟重连一次

    官网地址: https://www.yamdisplay.com/

其他参考

一秒把平板变 PC 电脑的扩展屏幕：TwomonUSB & Duet Display 对比评测

Yam Display-免费Mac扩展屏，让旧iPad成为Mac的第二个外接屏！

本文为作者原创 转载时请注明出处 谢谢

img

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

工程目录概览

UI编写

main.dart分析

1. StatelessWidget和StatefullWidget

image-20210728145631191

  • StatelessWidget: 无状态不可更新Widget，其build方法只在组件创建执行一次, 就是说一旦这个Widget创建完成，相关的属性配置就不允许再变动, 适用于属性固定不变的控件, 节约性能。
  • StatefulWidget:有状态可更新Widget，State类中的build方法可以通过调用setState函数来重复执行, 类似于android自定义控件中的invalidate, 适用于属性需要动态改变的控件, 比如点击或者网络请求后控件内容更新

注: 这种状态只针对当前控件有效, 不影响父控件或者子控件

2. 函数

  1. 在dart中函数形参, 我们可以使用大括号map形式的参数:

image-20210728154529647

也可以使用普通的形参表示:

image-20210728155125323

或者两者混搭:

image-20210728171730504

两者区别:

  • map形式: 传参时, 采用key:value的形式, 可设置默认值, 参数可传可不传

image-20210728154701753

  • 普通形式: 传参方式和java函数传参一样, 参数必传,否则报错

image-20210728155231818

此外, 我们还可以将函数当做参数进行传递:

image-20210728161913775

定义一个形参和返回值皆为函数的方法:

image-20210728165822497

一般这种写法太复杂, 为了简化写法, 我们可以给函数定义一个别名,类似于这种:

image-20210728170107196

这样看起来就清爽多了:

image-20210728170335274

  1. 内部匿名函数与外部函数

image-20210728170905542

当然 函数内部也可以声明函数:

image-20210728171034497

  1. 函数返回的简化写法:

image-20210728152316338

1
_MyHomePageState createState() => _MyHomePageState();

相当于

1
2
3
_MyHomePageState createState(){ 
	return  _MyHomePageState();
}
  1. UI的隐藏与显示

image-20210728163636872

Scaffold这个类为我们预制了很多控件, 类似于一个模板,我们可以对内置的控件进行排列组合, 需要显示的就定义, 不显示就不定义, 非常方便

本文为作者原创 转载时请注明出处 谢谢

img

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

枚举是 JDK 1.5 新增的数据类型，使用枚举我们可以很好的描述一些特定的业务场景，比如一年中的春、夏、秋、冬，还有每周的周一到周天，还有各种颜色，以及可以用它来描述一些状态信息，比如错误码等。

枚举类型不止存在在 Java 语言中，在其它语言中也都能找到它的身影，例如 C# 和 Python 等，但我发现在实际的项目中使用枚举的人很少，所以本文就来聊一聊枚举的相关内容，好让朋友们对枚举有一个大概的印象，这样在编程时起码还能想到有“枚举”这样一个类型。

本文的结构目录如下：

img

枚举的 7 种使用方法

很多人不使用枚举的一个重要的原因是对枚举不够熟悉，那么我们就先从枚举的 7 种使用方法说起。

用法一：常量

在 JDK 1.5 之前，我们定义常量都是 public static final... ，但有了枚举，我们就可以把这些常量定义成一个枚举类了，实现代码如下：

1
2
3
4
public enum ColorEnum {  
  RED, GREEN, BLANK, YELLOW  
} 
复制代码

用法二：switch

将枚举用在 switch 判断中，使得代码可读性更高了，实现代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
enum ColorEnum {
    GREEN, YELLOW, RED
}
public class ColorTest {
    ColorEnum color = ColorEnum.RED;

    public void change() {
        switch (color) {
            case RED:
                color = ColorEnum.GREEN;
                break;
            case YELLOW:
                color = ColorEnum.RED;
                break;
            case GREEN:
                color = ColorEnum.YELLOW;
                break;
        }
    }
}
复制代码

用法三：枚举中增加方法

我们可以在枚举中增加一些方法，让枚举具备更多的特性，实现代码如下：

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class EnumTest {
    public static void main(String[] args) {
        ErrorCodeEnum errorCode = ErrorCodeEnum.SUCCESS;
        System.out.println("状态码：" + errorCode.code() + 
                           " 状态信息：" + errorCode.msg());
    }
}

enum ErrorCodeEnum {
    SUCCESS(1000, "success"),
    PARAM_ERROR(1001, "parameter error"),
    SYS_ERROR(1003, "system error"),
    NAMESPACE_NOT_FOUND(2001, "namespace not found"),
    NODE_NOT_EXIST(3002, "node not exist"),
    NODE_ALREADY_EXIST(3003, "node already exist"),
    UNKNOWN_ERROR(9999, "unknown error");

    private int code;
    private String msg;

    ErrorCodeEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public int code() {
        return code;
    }

    public String msg() {
        return msg;
    }

    public static ErrorCodeEnum getErrorCode(int code) {
        for (ErrorCodeEnum it : ErrorCodeEnum.values()) {
            if (it.code() == code) {
                return it;
            }
        }
        return UNKNOWN_ERROR;
    }
}
复制代码

以上程序的执行结果为：

状态码：1000 状态信息：success

用法四：覆盖枚举方法

我们可以覆盖一些枚举中的方法用于实现自己的业务，比如我们可以覆盖 toString() 方法，实现代码如下：

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
public class EnumTest {
    public static void main(String[] args) {
        ColorEnum colorEnum = ColorEnum.RED;
        System.out.println(colorEnum.toString());
    }
}

enum ColorEnum {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLOW("黄色", 4);
    //  成员变量
    private String name;
    private int index;

    //  构造方法
    private ColorEnum(String name, int index) {
        this.name = name;
        this.index = index;
    }

    //覆盖方法
    @Override
    public String toString() {
        return this.index + "：" + this.name;
    }
}
复制代码

以上程序的执行结果为：

1：红色

用法五：实现接口

枚举类可以用来实现接口，但不能用于继承类，因为枚举默认继承了 java.lang.Enum 类，在 Java 语言中允许实现多接口，但不能继承多个父类，实现代码如下：

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
29
30
31
32
33
34
35
public class EnumTest {
    public static void main(String[] args) {
        ColorEnum colorEnum = ColorEnum.RED;
        colorEnum.print();
        System.out.println("颜色：" + colorEnum.getInfo());
    }
}

interface Behaviour {
    void print();

    String getInfo();
}

enum ColorEnum implements Behaviour {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLOW("黄色", 4);
    private String name;
    private int index;

    private ColorEnum(String name, int index) {
        this.name = name;
        this.index = index;
    }

    @Override
    public void print() {
        System.out.println(this.index + "：" + this.name);
    }

    @Override
    public String getInfo() {
        return this.name;
    }
}
复制代码

以上程序的执行结果为：

1：红色

颜色：红色

用法六：在接口中组织枚举类

我们可以在一个接口中创建多个枚举类，用它可以很好的实现“多态”，也就是说我们可以将拥有相同特性，但又有细微实现差别的枚举类聚集在一个接口中，实现代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class EnumTest {
    public static void main(String[] args) {
        // 赋值第一个枚举类
        ColorInterface colorEnum = ColorInterface.ColorEnum.RED;
        System.out.println(colorEnum);
        // 赋值第二个枚举类
        colorEnum = ColorInterface.NewColorEnum.NEW_RED;
        System.out.println(colorEnum);
    }
}

interface ColorInterface {
    enum ColorEnum implements ColorInterface {
        GREEN, YELLOW, RED
    }
    enum NewColorEnum implements ColorInterface {
        NEW_GREEN, NEW_YELLOW, NEW_RED
    }
}
复制代码

以上程序的执行结果为：

RED

NEW_RED

用法七：使用枚举集合

在 Java 语言中和枚举类相关的，还有两个枚举集合类 java.util.EnumSet 和 java.util.EnumMap，使用它们可以实现更多的功能。

使用 EnumSet 可以保证元素不重复，并且能获取指定范围内的元素，示例代码如下：

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;

public class EnumTest {
    public static void main(String[] args) {
        List<ColorEnum> list = new ArrayList<ColorEnum>();
        list.add(ColorEnum.RED);
        list.add(ColorEnum.RED);  // 重复元素
        list.add(ColorEnum.YELLOW);
        list.add(ColorEnum.GREEN);
        // 去掉重复数据
        EnumSet<ColorEnum> enumSet = EnumSet.copyOf(list);
        System.out.println("去重：" + enumSet);

        // 获取指定范围的枚举（获取所有的失败状态）
        EnumSet<ErrorCodeEnum> errorCodeEnums = EnumSet.range(ErrorCodeEnum.ERROR, ErrorCodeEnum.UNKNOWN_ERROR);
        System.out.println("所有失败状态：" + errorCodeEnums);
    }
}

enum ColorEnum {
    RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLOW("黄色", 4);
    private String name;
    private int index;

    private ColorEnum(String name, int index) {
        this.name = name;
        this.index = index;
    }
}

enum ErrorCodeEnum {
    SUCCESS(1000, "success"),
    ERROR(2001, "parameter error"),
    SYS_ERROR(2002, "system error"),
    NAMESPACE_NOT_FOUND(2003, "namespace not found"),
    NODE_NOT_EXIST(3002, "node not exist"),
    NODE_ALREADY_EXIST(3003, "node already exist"),
    UNKNOWN_ERROR(9999, "unknown error");

    private int code;
    private String msg;

    ErrorCodeEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public int code() {
        return code;
    }

    public String msg() {
        return msg;
    }
}
复制代码

以上程序的执行结果为：

去重：[RED, GREEN, YELLOW]

所有失败状态：[ERROR, SYS_ERROR, NAMESPACE_NOT_FOUND, NODE_NOT_EXIST, NODE_ALREADY_EXIST, UNKNOWN_ERROR]

EnumMap 与 HashMap 类似，不过它是一个专门为枚举设计的 Map 集合，相比 HashMap 来说它的性能更高，因为它内部放弃使用链表和红黑树的结构，采用数组作为数据存储的结构。

EnumMap 基本使用示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.EnumMap;

public class EnumTest {
    public static void main(String[] args) {
        EnumMap<ColorEnum, String> enumMap = new EnumMap<>(ColorEnum.class);
        enumMap.put(ColorEnum.RED, "红色");
        enumMap.put(ColorEnum.GREEN, "绿色");
        enumMap.put(ColorEnum.BLANK, "白色");
        enumMap.put(ColorEnum.YELLOW, "黄色");
        System.out.println(ColorEnum.RED + ":" + enumMap.get(ColorEnum.RED));
    }
}

enum ColorEnum {
    RED, GREEN, BLANK, YELLOW;
}
复制代码

以上程序的执行结果为：

RED:红色

使用注意事项

阿里《Java开发手册》对枚举的相关规定如下，我们在使用时需要稍微注意一下。

【强制】所有的枚举类型字段必须要有注释，说明每个数据项的用途。

【参考】枚举类名带上 Enum 后缀，枚举成员名称需要全大写，单词间用下划线隔开。说明：枚举其实就是特殊的常量类，且构造方法被默认强制是私有。正例：枚举名字为 ProcessStatusEnum 的成员名称：SUCCESS / UNKNOWN_REASON。

假如不使用枚举

在枚举没有诞生之前，也就是 JDK 1.5 版本之前，我们通常会使用 int 常量来表示枚举，实现代码如下：

1
2
3
4
public static final int COLOR_RED = 1;
public static final int COLOR_BLUE = 2;
public static final int COLOR_GREEN = 3;
复制代码

但是使用 int 类型可能存在两个问题：

第一， int 类型本身并不具备安全性，假如某个程序员在定义 int 时少些了一个 final 关键字，那么就会存在被其他人修改的风险，而反观枚举类，它“天然”就是一个常量类，不存在被修改的风险（原因详见下半部分）；

第二，使用 int 类型的语义不够明确，比如我们在控制台打印时如果只输出 1…2…3 这样的数字，我们肯定不知道它代表的是什么含义。

img

那有人就说了，那就使用常量字符呗，这总不会还不知道语义吧？实现示例代码如下：

1
2
3
4
public static final String COLOR_RED = "RED";
public static final String COLOR_BLUE = "BLUE";
public static final String COLOR_GREEN = "GREEN";
复制代码

但是这样同样存在一个问题，有些初级程序员会不按套路出牌，他们可能会直接使用字符串的值进行比较，而不是直接使用枚举的字段，实现示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
public class EnumTest {
    public static final String COLOR_RED = "RED";
    public static final String COLOR_BLUE = "BLUE";
    public static final String COLOR_GREEN = "GREEN";
    public static void main(String[] args) {
        String color = "BLUE";
        if ("BLUE".equals(color)) {
            System.out.println("蓝色");
        }
    }
}
复制代码

这样当我们修改了枚举中的值，那程序就凉凉了。

枚举使用场景

枚举的常见使用场景是单例，它的完整实现代码如下：

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
29
30
31
32
public class Singleton {
    // 枚举类型是线程安全的，并且只会装载一次
    private enum SingletonEnum {
        INSTANCE;
        // 声明单例对象
        private final Singleton instance;
        // 实例化
        SingletonEnum() {
            instance = new Singleton();
        }
        private Singleton getInstance() {
            return instance;
        }
    }
    // 获取实例（单例对象）
    public static Singleton getInstance() {
        return SingletonEnum.INSTANCE.getInstance();
    }
    private Singleton() {
    }
    // 类方法
    public void sayHi() {
        System.out.println("Hi,Java.");
    }
}
class SingletonTest {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.sayHi();
    }
}
复制代码

因为枚举只会在类加载时装载一次，所以它是线程安全的，这也是《Effective Java》作者极力推荐使用枚举来实现单例的主要原因。

知识扩展

枚举为什么是线程安全的？

这一点要从枚举最终生成的字节码说起，首先我们先来定义一个简单的枚举类：

1
2
3
4
public enum ColorEnumTest {
    RED, GREEN, BLANK, YELLOW;
}
复制代码

然后我们再将上面的那段代码编译为字节码，具体内容如下：

1
2
3
4
5
6
7
8
9
10
public final class ColorEnumTest extends java.lang.Enum<ColorEnumTest> {
  public static final ColorEnumTest RED;
  public static final ColorEnumTest GREEN;
  public static final ColorEnumTest BLANK;
  public static final ColorEnumTest YELLOW;
  public static ColorEnumTest[] values();
  public static ColorEnumTest valueOf(java.lang.String);
  static {};
}
复制代码

从上述结果可以看出枚举类最终会被编译为被 final 修饰的普通类，它的所有属性也都会被 static 和 final 关键字修饰，所以枚举类在项目启动时就会被 JVM 加载并初始化，而这个执行过程是线程安全的，所以枚举类也是线程安全的类。

小贴士：代码反编译的过程是先用 javac 命令将 java 代码编译字节码（.class），再使用 javap 命令查看编译的字节码。

枚举比较小技巧

我们在枚举比较时使用 == 就够了，因为枚举类是在程序加载时就创建了（它并不是 new 出来的），并且枚举类不允许在外部直接使用 new 关键字来创建枚举实例，所以我们在使用枚举类时本质上只有一个对象，因此在枚举比较时使用 == 就够了。

并且我们在查看枚举的 equlas() 源码会发现，它的内部其实还是直接调用了 == 方法，源码如下：

1
2
3
4
public final boolean equals(Object other) {
    return this==other;
}
复制代码

总结

本文我们介绍了枚举类的 7 种使用方法：常量、switch、枚举中添加方法、覆盖枚举方法、实现接口、在接口中组织枚举类和使用枚举集合等，然后讲了如果不使用枚举类使用 int 类型和 String 类型存在的一些弊端：语义不够清晰、容易被修改、存在被误用的风险，所以我们在适合的环境下应该尽量使用枚举类。并且我们还讲了枚举类的使用场景——单例，以及枚举类为什么是安全的，最后我们讲了枚举比较的小技巧，希望本文对你有帮助。

本文转载自:https://juejin.cn/post/6844904200652980231

img

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

Android和鸿蒙对比

组件

img

触摸事件

img

鸿蒙页面生命周期

img

本文为作者原创 转载时请注明出处 谢谢

img

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

发表于

前言

最近bintray好像不能用了, 以前传的依赖包全都挂了, 目前正在进行库转移

相比bintray而言 jitpack可以说是非常简单, 只需一个github就完全搞定了

快速上手

首先 将代码推送至github, 然后进入https://jitpack.io/

image-20210727145153403

绿色表示 编译成功 红色表示编译失败, 编译成功后 就可以开始使用库啦

image-20210727145906319

是不是非常简单

由于大部分人习惯使用版本号的依赖形式, 因此 如果你想将commitId换成版本号, 那么只需在github上push release即可, 如下:

image-20210727150302447

image-20210727150429243

创建成功后,回到jitpack主页刷新, 此时在Release一栏下出现相应的版本

image-20210727150604728

我们发现1.0.5版本的Log一栏是红色, 我们可以点击进入查看编译日志 寻找编译失败原因

image-20210727150827296

如果编译成功, 将会生成相应的jar包并存储在jitpack仓库中

image-20210727151000773

此时我们就可以使用版本号形式的啦

image-20210727151055721

注意事项

  • 对于android 必须是Lib库 而不是APP
  • 由于jitpack会对整个项目库进行编译打包, 因此项目中避免出现多个库的情况, 如果是android 可以在settings.gradle里面进行注释屏蔽

除了github之外,jitpack还支持以下仓库:

image-20210727153831851

本文为作者原创 转载时请注明出处 谢谢

img

乱码三千 – 点滴积累 ,欢迎来到乱码三千技术博客站

0%