ASP.NET Core 企业开发架构概述

企业开发框架包括垂直方向架构和水平方向架构。垂直方向架构是指一个应用程序的由下到上叠加多层的架构，同时这样的程序又叫整体式程序。水平方向架构是指将大应用分成若干小的应用实现系统功能的架构，同时这样的系统叫做分布式系统。在架构上java和.net世界都有优秀的框架支持构建垂直和水平方向架构。ASP.Net Core非常轻量且具有很高的性能，不仅适合做整体式程序，也非常适合做分布式系统。随着微服务的兴起，各种语言的混合应用是个趋势。   目录 一、 垂直方向架构 1. 多层架构 1.1 领域模型 1.2 存储仓库 1.3 服务 1.4 UI 2. 典型框架 2.1 数据存储框架 2.1.1 数据访问辅助 2.1.2 对象-关系映射 2.2 MVC 框架 2.2.1 经典MVC模式 2.2.2 后端MVC模式 2.2.3 典型框架 2.2.4 MVC模式总结 2.3 IOC框架 2.3.1 概念 2.3.2 典型注入框架 二、 水平方向架构 1. SOA架构 1.1 简洁版架构 1.2 服务的基本要素 1.3 服务治理 2. 微服务架构 2.1 简洁版架构 2.2 服务的基本要素 2.3 服务治理 3. 整体式 vs SOA架构 vs 微服务架构 4. SOA典型框架 5. 微服务典型框架 三、 总结   1. 多层架构 分层架构通过程序包或者程序的隔离构建松耦合的应用。我们以最近流行的洋葱架构模型进行分析，如图 1.1 领域模型 包括领域实体/存储接口/服务接口，是整个程序的核心。 贫血模型 如果把大量的业务逻辑委托给服务接口实现者，领域模型显得很瘦小，就可以称之为贫血模型。这种模型下的领域对象仅仅表示“状态”。“行为”（也称为逻辑、过程）放在了N层结构的Logic/Service/Manager层中。优点是易于理解和实现，缺点是随着业务发展模型会难以表达业务领域。目前不少业内软件架构是这种模式。 贫血模型的简单图示：     充血模型 如果在领域模型中实现主要的业务逻辑，把不方便实现的业务（比如汇率结算，地理坐标解析等）委托给服务接口实现者，此时领域模型显得粗壮，就可以称之为充血模型。这种模型下的领域对象既表示“状态”又有”行为“，领域对象之间还通过聚合在一个根（聚合根），然后由根对象保证状态的一致性（类似于数据库表之间的约束一致性）。优点是模型易于跟进业务发展，容易通过重构表达最新的业务领域；缺点是不易掌握。 充血模型的简单图示：     […]

龙生   28 Apr 2019
View Details

SOA架构和微服务架构的区别

1.SOA架构和微服务架构的区别 首先SOA和微服务架构一个层面的东西，而对于ESB和微服务网关是一个层面的东西，一个谈到是架构风格和方法，一个谈的是实现工具或组件。  1.SOA（Service Oriented Architecture）“面向服务的架构”:他是一种设计方法，其中包含多个服务， 服务之间通过相互依赖最终提供一系列的功能。一个服务 通常以独立的形式存在与操作系统进程中。各个服务之间 通过网络调用。  2.微服务架构:其实和 SOA 架构类似,微服务是在 SOA 上做的升华，微服务架构强调的一个重点是“业务需要彻底的组件化和服务化”，原有的单个业务系统会拆分为多个可以独立开发、设计、运行的小应用。这些小应用之间通过服务完成交互和集成。  微服务架构 = 80%的SOA服务架构思想 + 100%的组件化架构思想 + 80%的领域建模思想 2.ESB和微服务API网关。 1.ESB（企业服务总线），简单 来说 ESB 就是一根管道，用来连接各个服务节点。为了集 成不同系统，不同协议的服务，ESB 做了消息的转化解释和路由工作，让不同的服务互联互通； 2.API网关:API网关是一个服务器，是系统的唯一入口。从面向对象设计的角度看，它与外观模式类似。API网关封装了系统内部架构，为每个客户端提供一个定制的API。它可能还具有其它职责，如身份验证、监控、负载均衡、缓存、请求分片与管理、静态响应处理。API网关方式的核心要点是，所有的客户端和消费端都通过统一的网关接入微服务，在网关层处理所有的非业务功能。通常，网关也是提供REST/HTTP的访问API。服务端通过API-GW注册和管理服务。       3.SOA架构特点： 系统集成：站在系统的角度，解决企业系统间的通信问 题，把原先散乱、无规划的系统间的网状结构，梳理成 规整、可治理的系统间星形结构，这一步往往需要引入 一些产品，比如 ESB、以及技术规范、服务管理规范； 这一步解决的核心问题是【有序】 系统的服务化：站在功能的角度，把业务逻辑抽象成 可复用、可组装的服务，通过服务的编排实现业务的 快速再生，目的：把原先固有的业务功能转变为通用 的业务服务，实现业务逻辑的快速复用；这一步解决 的核心问题是【复用】 业务的服务化：站在企业的角度，把企业职能抽象成 可复用、可组装的服务；把原先职能化的企业架构转变为服务化的企业架构，进一步提升企业的对外服务能力；“前面两步都是从技术层面来解决系统调用、系统功能复用的问题”。第三步，则是以业务驱动把一个业务单元封装成一项服务。这一步解决的核心问题是【高效】 4.微服务架构特点： 1.通过服务实现组件化   开发者不再需要协调其它服务部署对本服务的影响。 2.按业务能力来划分服务和开发团队   开发者可以自由选择开发技术，提供 API 服务 3.去中心化   每个微服务有自己私有的数据库持久化业务数据 每个微服务只能访问自己的数据库，而不能访问其它服务的数据库 某些业务场景下，需要在一个事务中更新多个数据库。这种情况也不能直接访问其它微服务的数据库，而是通过对于微服务进行操作。 数据的去中心化，进一步降低了微服务之间的耦合度，不同服务可以采用不同的数据库技术（SQL、NoSQL等）。在复杂的业务场景下，如果包含多个微服务，通常在客户端或者中间层（网关）处理。 4.基础设施自动化（devops、自动化部署）   的Java EE部署架构，通过展现层打包WARs，业务层划分到JARs最后部署为EAR一个大包，而微服务则打开了这个黑盒子，把应用拆分成为一个一个的单个服务，应用Docker技术，不依赖任何服务器和数据模型，是一个全栈应用，可以通过自动化方式独立部署，每个服务运行在自己的进程中，通过轻量的通讯机制联系，经常是基于HTTP资源API，这些服务基于业务能力构建，能实现集中化管理（因为服务太多啦，不集中管理就无法DevOps啦）。 5.主要区别： 功能 SOA 微服务 组件大小 大块业务逻辑 单独任务或小块业务逻辑 耦合 通常松耦合 总是松耦合 公司架构 任何类型 小型、专注于功能交叉团队 管理 着重中央管理 着重分散管理 目标 确保应用能够交互操作 执行新功能、快速拓展开发团队   6.Dubbo服务的最佳实践  分包   服务接口、请求服务模型、异常信息都放在api里面，符合重用发布等价原则，共同重用原则 […]

龙生   28 Apr 2019
View Details

devops

DevOps（Development和Operations的组合词）是一组过程、方法与系统的统称，用于促进开发（应用程序/软件工程）、技术运营和质量保障（QA）部门之间的沟通、协作与整合。 它是一种重视“软件开发人员（Dev）”和“IT运维技术人员（Ops）”之间沟通合作的文化、运动或惯例。透过自动化“软件交付”和“架构变更”的流程，来使得构建、测试、发布软件能够更加地快捷、频繁和可靠。 它的出现是由于软件行业日益清晰地认识到：为了按时交付软件产品和服务，开发和运营工作必须紧密合作。 from:https://baike.baidu.com/item/devops/2613029

龙生   28 Apr 2019
View Details

Selenium

Selenium 是一个用于Web应用程序测试的工具。Selenium测试直接运行在浏览器中，就像真正的用户在操作一样。支持的浏览器包括IE（7, 8, 9, 10, 11），Mozilla Firefox，Safari，Google Chrome，Opera等。这个工具的主要功能包括：测试与浏览器的兼容性——测试你的应用程序看是否能够很好得工作在不同浏览器和操作系统之上。测试系统功能——创建回归测试检验软件功能和用户需求。支持自动录制动作和自动生成 .Net、Java、Perl等不同语言的测试脚本。 from:https://baike.baidu.com/item/selenium/18266

龙生   25 Apr 2019
View Details

spring cloud 入门系列二：使用Eureka 进行服务治理

服务治理可以说是微服务架构中最为核心和基础的模块，它主要用来实现各个微服务实例的自动化注册和发现。 Spring Cloud Eureka是Spring Cloud Netflix 微服务套件的一部分，主要负责完成微服务架构中的服务治理功能。 本文通过简单的小例子来分享下如何通过Eureka进行服务治理： 搭建服务注册中心 注册服务提供者 服务发现和消费 ==========我是华丽的分割线======================== 一、搭建服务注册中心 　　先列出完整目录结构： 　　 搭建过程如下： 创建maven工程：eureka(具体实现略) 修改pom文件，引入依赖

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
<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>com.sam</groupId>
    <artifactId>eureka</artifactId>
    <version>0.0.1-SNAPSHOT</version>
 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
    </parent>
 
    <properties>
        <javaVersion>1.8</javaVersion>
    </properties>
    <!-- 使用dependencyManagement进行版本管理 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Camden.SR6</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
 
    </dependencyManagement>
 
    <dependencies>
        <!-- 引入eureka server依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
        </dependency>
 
    </dependencies>
 
</project>

创建启动类

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
*
* @EnableEurekaServer
* 用来指定该项目为Eureka的服务注册中心
*/
@EnableEurekaServer
@SpringBootApplication
public class EurekaApp {
 
    public static void main(String[] args) {
        SpringApplication.run(EurekaApp.class, args);
    }
}

配置application.properties文件

1
2
3
4
5
6
7
8
9
10
11
12
#设置tomcat服务端口号
server.port=1111
#设置服务名称
spring.application.name=eureka-service
 
eureka.instance.hostname=localhost
#注册中心不需要注册自己
eureka.client.register-with-eureka=false
#注册中心不需要去发现服务
eureka.client.fetch-registry=false
#设置服务注册中心的URL
eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka

启动服务并访问，我们会看到这样的画面：  二、注册服务提供者 先列出完整目录结构： 搭建过程如下： 创建maven工程：hello-service(具体实现略) 修改pom文件，引入依赖

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
<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>com.sam</groupId>
    <artifactId>hello-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
    </parent>
 
    <properties>
        <javaVersion>1.8</javaVersion>
    </properties>
 
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Camden.SR6</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
 
    </dependencyManagement>
 
    <dependencies>
        <!-- 引入eureka 客户端依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
 
    </dependencies>
</project>

创建启动类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/***
*
* @EnableDiscoveryClient
* 让服务使用eureka服务器
* 实现服务注册和发现
*
*/
@EnableDiscoveryClient
@SpringBootApplication
public class HelloApp {
 
    public static void main(String[] args) {
 
        SpringApplication.run(HelloApp.class, args);
    }
 
}

创建controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@RestController
public class HelloController {
 
    Logger logger = LoggerFactory.getLogger(HelloController.class);
 
    @Autowired
    DiscoveryClient discoveryClient;
    
    @RequestMapping("/hello")
    public String hello() {
        ServiceInstance instance = discoveryClient.getLocalServiceInstance();
        //打印服务的服务id
        logger.info("*********" + instance.getServiceId());
        return "hello,this is hello-service";
    }
}

配置application.properties文件

1
2
3
4
5
server.port=9090
#设置服务名
spring.application.name=hello-service
#设置服务注册中心的URL，本服务要向该服务注册中心注册自己
eureka.client.serviceUrl.defaultZone=http://localhost:1111/eureka

启动并测试 ）启动后再hello-service的控制台会有这种字样(xxx代表你的PC名)

1
Registered instance HELLO-SERVICE/xxx:hello-service:9090 with status UP (replication=false)

eureka的控制台会打印出如下字样(xxx代表你的PC名)

1
Registered instance HELLO-SERVICE/xxx:hello-service:9090 with status UP (replication=false)

）再次访问localhost:1111,会发现有服务注册到注册中心了  三、服务发现和消费 完整目录结构如下： 搭建过程： 创建maven工程(具体实现略) 修改pom文件，引入依赖

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
<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>com.sam</groupId>
    <artifactId>hello-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
    </parent>
 
    <properties>
        <javaVersion>1.8</javaVersion>
    </properties>
 
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Camden.SR6</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
 
    </dependencyManagement>
 
    <dependencies>
        <!-- 引入eureka 客户端依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <!-- 引入ribbon 依赖 ，用来实现负载均衡，我们这里只是使用，先不作其他介绍-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>
 
    </dependencies>
</project>
 
这里比hello-service服务提供者，多了ribbon的依赖

创建启动类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@EnableDiscoveryClient
@SpringBootApplication
public class ConsumerApp {
 
 
    //@Bean 应用在方法上，用来将方法返回值设为为bean
    @Bean
    @LoadBalanced  //@LoadBalanced实现负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApp.class, args);
    }
}

1
这里也要用到@EnableDiscoveryClient， 让服务使用eureka服务器， 实现服务注册和发现

创建controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RestController
public class ConsumerController {
 
    //这里注入的restTemplate就是在com.sam.ConsumerApp中通过@Bean配置的实例
    @Autowired
    RestTemplate restTemplate;
 
    @RequestMapping("/hello-consumer")
    public String helloConsumer() {
        //调用hello-service服务，注意这里用的是服务名，而不是具体的ip+port
        restTemplate.getForObject("http://hello-service/hello", String.class);
        return "hello consumer finish !!!";
    }
}

配置application.properties文件

1
2
3
4
5
6
7
server.port=9999
 
spring.application.name=hello-consumer
eureka.client.serviceUrl.defaultZone=http://localhost:1111/eureka
 
 
#这里的配置项目和服务提供者hello-service一样

启动，测试 ）启动eureka。为了展示负责均衡的效果，我们的hello-service启动两个服务，启动两个服务的具体步骤如下 以上是hello-service1的启动步骤，端口号为9090；同样方法设置hello-service2，端口号为9091(具体实现略)。 ）启动hello-consumer ）再次访问http://localhost:1111/，会发现有2个hello-service服务（端口号一个是9090，一个是9091），1个hello-consume服务 )   多次访问http://localhost:9999/hello-consumer，会发现hello-service1和hello-service2会轮流被调用（已经实现了负责均衡），可以通过两者的控制台打印内容确认（还记得我们在hello-service的controller中有个loggerlogger.info("*********" + instance.getServiceId());吗？对，就是这个打印）   四、总结 以上实例实现了基本的服务治理： 通过spring-cloud-starter-eureka-server和@EnableEurekaServer实现服务注册中心 通过spring-cloud-starter-eureka和@EnableDiscoveryClient使用并注册到服务注册中心 通过spring-cloud-starter-eureka和@EnableDiscoveryClient使用注册中心并发现服务，通过spring-cloud-starter-ribbon来实现负载均衡消费服务 PS：这里说明下，我用的IDE是Spring Tool Suite，是spring定制版的eclipse，方便我们使用spring进行开发，有兴趣的朋友可以自行百度了解下。   from:https://www.cnblogs.com/sam-uncle/p/8954401.html

龙生   24 Apr 2019
View Details

Eureka

Eureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中，以实现SpringCloud的服务发现功能。 Eureka包含两个组件：Eureka Server和Eureka Client。 Eureka Server提供服务注册服务，各个节点启动后，会在Eureka Server中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。 Eureka Client是一个java客户端，用于简化与Eureka Server的交互，客户端同时也就是一个内置的、使用轮询(round-robin)负载算法的负载均衡器。 在应用启动后，将会向Eureka Server发送心跳,默认周期为30秒，如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，Eureka Server将会从服务注册表中把这个服务节点移除(默认90秒)。 Eureka Server之间通过复制的方式完成数据的同步，Eureka还提供了客户端缓存机制，即使所有的Eureka Server都挂掉，客户端依然可以利用缓存中的信息消费其他服务的API。综上，Eureka通过心跳检查、客户端缓存等机制，确保了系统的高可用性、灵活性和可伸缩性。 from:https://baike.baidu.com/item/Eureka/22402835?fr=aladdin

龙生   24 Apr 2019
View Details

一次删除多个需要git rm的文件

For Git 1.x

1
$ git add -u

  This tells git to automatically stage tracked files — including deleting the previously tracked files. For Git 2.0 To stage your whole working tree:

1
$ git add -u :/

  To stage just the current path:

1
$ git add -u .

  from:https://blog.csdn.net/dahailantian1/article/details/79475644

龙生   22 Apr 2019
View Details

git<撤销本地修改与回退版本>

1. 使用 git checkout 撤销本地修改 即放弃对本地已修改但尚未提交的文件的修改，还原其到未修改前的状态。 注意： 已 add/ commit 的文件不适用个方法，应该用本文提到的第二种方法。 命令如下：

1
2
git checkout .      # 撤销对所有已修改但未提交的文件的修改，但不包括新增的文件
git checkout [filename]     # 撤销对指定文件的修改，[filename]为文件名

  2. 使用 git reset 回退项目版本 可以回退到任意已经提交过的版本。已 add / commit 但未 push 的文件也适用。 命令如下： 1git reset --hard [commit-hashcode] 2# [commit-hashcode]是某个 commit 的哈希值，可以用 git log 查看 因此一般用法是先用 Git log 查看具体commit的哈希值，然后 reset 到那个版本。 说明： 这两个命令都不会对新增文件起作用。因为新增的文件是还未加到 git 的记录里面的，即属于未被 tracked 的状态，所以撤销修改和回退均对其不影响。我们直接手动删除文件就行了。   转自：http://blog.csdn.net/dandelion_drq/article/details/51259831   from:https://www.cnblogs.com/runningdonkey/p/6932437.html

龙生   16 Apr 2019
View Details

react-navigation示例

App.js

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
import React, { Component } from 'react'
import { Platform, StyleSheet, Text, View } from 'react-native'
import { createStackNavigator, createAppContainer } from 'react-navigation'
import HomeScreen from './pages/HomeScreen'
import ProfileScreen from './pages/ProfileScreen.js'
 
 
const navigator = createStackNavigator({
  Home: { screen: HomeScreen },
  Profile: { screen: ProfileScreen }
})
 
const App = createAppContainer(navigator)
 
export default App
 
const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#F5FCFF'
  },
  welcome: {
    fontSize: 20,
    textAlign: 'center',
    margin: 10
  },
  instructions: {
    textAlign: 'center',
    color: '#333333',
    marginBottom: 5
  }
})

  pages/ProfileScreen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import React, { Component } from 'react'
import { Text, StyleSheet, View } from 'react-native'
 
export default class ProfileScreen extends Component {
  static navigationOptions = {
    title: 'ProfileScreen'
  }
  render() {
    return (
      <View>
        <Text> 2 </Text>
      </View>
    )
  }
}
 
const styles = StyleSheet.create({})

  pages/HomeScreen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import React, { Component } from 'react'
import { Text, StyleSheet, View, Button } from 'react-native'
import { createStackNavigator, createAppContainer } from 'react-navigation';
export default class HomeScreen extends Component {
  static navigationOptions = {
    title: 'HomeScreen'
  }
  render() {
    return (
      <View>
        <Text> one </Text>
        <Button title="go to two" onPress={() => this.props.navigation.navigate('Profile')} />
      </View>
    )
  }
}
 
const styles = StyleSheet.create({})

  然后报错： undefined is not an object (evaluating ‘RNGestureHandlerModule.State’ 解决办法： npm install npm install --save react-navigation npm install --save react-native-gesture-handler react-native link   参考： https://www.cnblogs.com/wuvkcyan/p/10011012.html https://blog.csdn.net/quhongqiang/article/details/86597694

龙生   15 Apr 2019
View Details

处理文本输入

TextInput是一个允许用户输入文本的基础组件。它有一个名为onChangeText的属性，此属性接受一个函数，而此函数会在文本变化时被调用。另外还有一个名为onSubmitEditing的属性，会在文本被提交后（用户按下软键盘上的提交键）调用。 假如我们要实现当用户输入时，实时将其以单词为单位翻译为另一种文字。我们假设这另一种文字来自某个吃货星球，只有一个单词： 🍕。所以"Hello there Bob"将会被翻译为"🍕🍕🍕"。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import React, { Component } from 'react';
import { AppRegistry, Text, TextInput, View } from 'react-native';
 
export default class PizzaTranslator extends Component {
  constructor(props) {
    super(props);
    this.state = {text: ''};
  }
 
  render() {
    return (
      <View style={{padding: 10}}>
        <TextInput
          style={{height: 40}}
          placeholder="Type here to translate!"
          onChangeText={(text) => this.setState({text})}
        />
        <Text style={{padding: 10, fontSize: 42}}>
          {this.state.text.split(' ').map((word) => word && '🍕').join(' ')}
        </Text>
      </View>
    );
  }
}

在上面的例子里，我们把text保存到 state 中，因为它会随着时间变化。 文本输入方面还有很多其他的东西要处理。比如你可能想要在用户输入的时候进行验证，在React 中的受限组件一节中有一些详细的示例（注意 react 中的 onChange 对应的是 rn 中的 onChangeText）。此外你还需要看看TextInput 的文档。 TextInput 可能是天然具有“动态状态”的最简单的组件了。下面我们来看看另一类输入组件，先从如何处理触摸开始学习。 from:https://reactnative.cn/docs/handling-text-input/

龙生   14 Apr 2019
View Details
1 … 161 162 163 … 414

Copyright © 2025 Longsheng All rights reserved