转自 静心梦工厂_cmd 调用 blockinput

Android开源git40个App源码

使用PowerDesinger将mysql（oracle、sqlServer）中的数据库逆向生成为PDM文件

让PIP源使用国内镜像，提升下载速度和安装成功率。

[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple

[install]
trusted-host=mirrors.aliyun.com

Spring Boot 中使用 Dubbo 详解

Dubbo是阿里巴巴SOA服务化治理方案的核心框架，每天为2,000+个服务提供3,000,000,000+次访问量支持，并被广泛应用于阿里巴巴集团的各成员站点。Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。

Dubbo 简介

Dubbo 是什么？

Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。简单的说，dubbo就是个服务框架，如果没有分布式的需求，其实是不需要用的，只有在分布式的时候，才有dubbo这样的分布式服务框架的需求，并且本质上是个服务调用的东东，说白了就是个远程服务调用的分布式框架

其核心部分包含:

1.远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。
2.集群容错: 提供基于接口方法的透明远程过程调用，包括多协议支持，以及软负载均衡，失败容错，地址路由，动态配置等集群支持。
3.自动发现: 基于注册中心目录服务，使服务消费方能动态的查找服务提供方，使地址透明，使服务提供方可以平滑增加或减少机器。

Dubbo 能做什么？

1.透明化的远程方法调用，就像调用本地方法一样调用远程方法，只需简单配置，没有任何API侵入。
2.软负载均衡及容错机制，可在内网替代F5等硬件负载均衡器，降低成本，减少单点。
3.服务自动注册与发现，不再需要写死服务提供方地址，注册中心基于接口名查询服务提供者的IP地址，并且能够平滑添加或删除服务提供者。

Dubbo 的架构

架构图

节点角色说明

节点	角色说明
Provider	暴露服务的服务提供方
Consumer	调用远程服务的服务消费方
Registry	服务注册与发现的注册中心
Monitor	统计服务的调用次调和调用时间的监控中心
Container	服务运行容器

Dubbo提供三个关键功能，包括基于接口的远程呼叫，容错和负载平衡以及自动服务注册和发现

调用关系说明

1.服务容器负责启动，加载，运行服务提供者。
2.服务提供者在启动时，向注册中心注册自己提供的服务。
3.服务消费者在启动时，向注册中心订阅自己所需的服务。
4.注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
5.服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
6.服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

Dubbo 特点

Dubbo 架构具有以下几个特点，分别是连通性、健壮性、伸缩性、以及向未来架构的升级性

连通性

• 注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者和消费者只在启动时与注册中心交互，注册中心不转发请求，压力较小
• 监控中心负责统计各服务调用次数，调用时间等，统计先在内存汇总后每分钟一次发送到监控中心服务器，并以报表展示
• 服务提供者向注册中心注册其提供的服务，并汇报调用时间到监控中心，此时间不包含网络开销
• 服务消费者向注册中心获取服务提供者地址列表，并根据负载算法直接调用提供者，同时汇报调用时间到监控中心，此时间包含网络开销
• 注册中心，服务提供者，服务消费者三者之间均为长连接，监控中心除外
• 注册中心通过长连接感知服务提供者的存在，服务提供者宕机，注册中心将立即推送事件通知消费者
• 注册中心和监控中心全部宕机，不影响已运行的提供者和消费者，消费者在本地缓存了提供者列表
• 注册中心和监控中心都是可选的，服务消费者可以直连服务提供者

健状性

• 监控中心宕掉不影响使用，只是丢失部分采样数据
• 数据库宕掉后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务
• 注册中心对等集群，任意一台宕掉后，将自动切换到另一台
• 注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯
• 服务提供者无状态，任意一台宕掉后，不影响使用
• 服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复

伸缩性

• 注册中心为对等集群，可动态增加机器部署实例，所有客户端将自动发现新的注册中心
• 服务提供者无状态，可动态增加机器部署实例，注册中心将推送新的服务提供者信息给消费者

升级性

当服务集群规模进一步扩大，带动IT治理结构进一步升级，需要实现动态部署，进行流动计算，现有分布式服务架构不会带来阻力。下图是未来可能的一种架构：

未来可能的一种架构

节点角色说明

节点	角色说明
Deployer	自动部署服务的本地代理
Repository	仓库用于存储服务应用发布包
Scheduler	调度中心基于访问压力自动增减服务提供者
Admin	统一管理控制台
Registry	服务注册与发现的注册中心
Monitor	统计服务的调用次调和调用时间的监控中心

快速开始

Dubbo 采用全 Spring 配置方式，透明化接入应用，对应用没有任何 API 侵入，只需用 Spring 加载 Dubbo 的配置即可，Dubbo 基于 Spring 的 Schema 扩展进行加载。

环境安装

任选其一

CentOs7.3 搭建 ZooKeeper-3.4.9 单机服务
CentOs7.3 搭建 ZooKeeper-3.4.9 Cluster 集群服务

Github 代码

代码我已放到 Github ，导入ymq-dubbo-spring-boot 项目

github github.com/souyunku/ym…

Maven依赖

在项目中添加 dubbo 依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dubbo</artifactId>
    <version>2.5.6</version>
</dependency>

定义服务接口

项目：ymq-dubbo-api

public interface DemoService {
    String sayHello(String name);
}

服务提供方

项目：ymq-dubbo-provider，在服务提供方实现接口

@Service("demoService")
public class DemoServiceImpl implements DemoService {
 
    @Override
    public String sayHello(String name) {
        System.out.println("[" + new SimpleDateFormat("HH:mm:ss").format(new Date()) + "] Hello " + name + ", request from consumer: " + RpcContext.getContext().getRemoteAddress());
        return "Hello " + name + ", response form provider: " + RpcContext.getContext().getLocalAddress();
    }
}

加载 dubbo 配置

@Configuration
@PropertySource("classpath:dubbo.properties")
@ImportResource({"classpath:dubbo/*.xml"})
public class PropertiesConfig {
}

在提供方增加暴露服务配置 : <dubbo:service>

dubbo-provider.xml

<!-- 声明需要暴露的服务接口 -->
<dubbo:service interface="io.ymq.dubbo.api.DemoService" ref="demoService"/>

服务消费方

项目：ymq-dubbo-consumer ，消费消费远程方法

@Service("consumerDemoService")
public class ConsumerDemoService {
 
    @Autowired
    private DemoService demoService;
 
    public void sayHello(String name) {
        String hello = demoService.sayHello(name); // 执行消费远程方法
        System.out.println(hello); // 显示调用结果
    }
 
}

加载 dubbo 配置

@Configuration
@PropertySource("classpath:dubbo.properties")
@ImportResource({"classpath:dubbo/*.xml"})
public class PropertiesConfig {
}

在消费方增加引用服务配置: <dubbo:reference>

dubbo-consumer.xml

<!-- 增加引用远程服务配置 可以和本地bean一样使用demoService -->
<dubbo:reference id="demoService" check="false" interface="io.ymq.dubbo.api.DemoService"/>

远程服务 Dubbo 配置

项目：ymq-dubbo-provider ,ymq-dubbo-consumer 一样配置

dubbo.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    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.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 
    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name="${spring.application.name}"  />
 
    <!-- 使用multicast广播注册中心暴露服务地址 -->
    <dubbo:registry protocol="zookeeper" address="${zookeeper.connect}"  file="${dubbo.cache}"/>
 
    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="${dubbo.protocol.port}"  threadpool="${dubbo.protocol.threadpool}"  threads="${dubbo.protocol.threads}"/>
 
    <!-- 提供方的缺省值，当ProtocolConfig和ServiceConfig某属性没有配置时，采用此缺省值，可选。-->
    <dubbo:provider connections="${dubbo.provider.connections}" timeout="${dubbo.provider.timeout}" retries="${dubbo.provider.retries}" version="${dubbo.provider.version}" />
 
    <!-- 消费方缺省配置，当ReferenceConfig某属性没有配置时，采用此缺省值，可选。-->
    <dubbo:consumer version="${dubbo.provider.version}" />
 
    <!-- 监控中心配置，用于配置连接监控中心相关信息，可选。-->
    <dubbo:monitor protocol="registry"/>
 
</beans>

dubbo.properties

#########################################################
# dubbo config
#暴露服务端口
dubbo.protocol.port=20880
#提供方超时时间
dubbo.provider.timeout=10000
#提供方版本
dubbo.provider.version=1.0
#表示该服务使用独的五条条长连
dubbo.provider.connections=5
# 固定大小线程池，启动时建立线程，不关闭，一直持有。(缺省)
dubbo.protocol.threadpool=fixed
# 线程数量
dubbo.protocol.threads=500
#配置重试次数，最好只用于读的重试，写操作可能会引起多次写入  默认retries="0"
dubbo.provider.retries=0
# dubbo缓存文件
dubbo.cache=/data/dubbo/cache/ymq-dubbo-provider
#########################################################
# zookeeper config
zookeeper.connect=127.0.0.1:2181

测试 Dubbo

1. 该接口需单独打包，在服务提供方和消费方共享 ↩
2. 对服务消费方隐藏实现 ↩
3. 也可以使用 IoC 注入 ↩

启动 ZooKeeper

启动服务

/opt/zookeeper-3.4.9/bin/zkServer.sh start

启动提供方服务

package io.ymq.dubbo.provider.run;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
 
/**
 * 描述:启动提供方服务
 *
 * @author yanpenglei
 * @create 2017-10-27 11:49
 **/
@SpringBootApplication
@ComponentScan(value = {"io.ymq.dubbo"})
public class Startup {
 
    public static void main(String[] args) {
        SpringApplication.run(Startup.class, args);
    }
}

测试消费远程服务

package io.ymq.dubbo.test;
 
import io.ymq.dubbo.consumer.run.Startup;
import io.ymq.dubbo.consumer.service.ConsumerDemoService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
 
/**
 * 描述: 测试消费远程服务
 *
 * @author yanpenglei
 * @create 2017-10-27 14:15
 **/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Startup.class)
public class ConsumerTest {
 
    @Autowired
    private ConsumerDemoService consumerDemoService;
 
    @Test
    public void sayHello(){
        consumerDemoService.sayHello("Peng Lei");
    }
}

响应：

[15:54:00] Hello Peng Lei, request from consumer: /10.4.82.6:63993

代码我已放到 Github ，导入ymq-dubbo-spring-boot 项目

github github.com/souyunku/ym…

• 作者：Peng Lei
• 出处：Segment Fault PengLei `Blog 专栏
• 版权归作者所有，转载请注明出处

Android 开发资料便签

标签：Android

• 本文Github链接地址
• 本文CSDN链接地址
• 本文MD版本阅读链接地址

平台

技术

阅读

权威导航

我的书签

• Android资料便签—CSDN
• Android技术笔记—看云
• Android-bookmark-shares
• Android 资源库

第三方书签

• codekk(Trinea运营的专注Android开发的技术网站)
• awesome-android-snowdream
• awesome-android-JStumpp
• TimLiu-Android
• awesome-android-performance
• awesome-android-libraries
• mobdevgroup(github地址)(2016-10-06)
• XXApple
• Android_Data-Android
• android-training-course-in-chinese
• awesome-android-cn
• AndroidLibs
• AndroidTips
• android-open-source-project-cracking
• android sdk源码分析
• android_design_patterns_analysis
• share
• AndroidGuide
• android-dev-bookmarks
• CoreLink 日常积累
• Android-Tips
• android-dev-cn
• AndroidNote-GcsSloop
• AndroidNote-CharonChui
• AndroidNote-venshine
• AndroidNote-linsir6
• AndroidDifficultAnalysis

其它书签

• Awesome-java-cn
• awesome-github
• be-a-professional-programmer
• gogeeks 极客导航，非常便利的开发综合导航
• 技能图谱
• awesome-android
• awesome-android-ui
• awesome-machine-learning
• github-cheat-sheet
• awesome-interview-questions
• Awesome-RxJava
• awesome-android-libraries
• awesome-adb
• Awesome_APIs
• awesome-android-performance
• android-security-awesome
• awesome-android-tips
• material-design-data 关于 Material Design 的一切资料都在这里
• awesome-github-android-ui
• awesome-github

信息中心

1:社区网站

• Android开发官方网站
• 掘金|高质量的技术社区

2:技术源码

• Android API
• Android API 指南
• Android各个版本源码在线查看，包括系统,api,support-library源码
• Android API源码
• Android support-library源码
• Android 版本最新市场分布情况
• Android support-library 安装与使用
• Android support-library 详细依赖关系查询
• Android support-library 详细依赖关系查询 中文
• Android Plugin for Gradle Release Notes|android studio版本与com.android.tools.build:gradle版本的对应关系 官方地址
• APK安装错误码

工具利器

• JDK
• Android studio
• Gradle
• dexcount-gradle-plugin 方法数统计
• Android Shapes在线生成Shapes
• Android Buttons在线生成Buttons
• Android Pixel Calculator DP单位换算
• Android .9图在线制作

进阶书籍

• Java编程思想
• Android高级进阶
• Android群英传
• Android艺术探索
• Android源码设计模式

开发规范

• Android 开发最佳实践
• Android 项目规范
• Gradle插件用户指南(译)(系统性学习Grade的不错中文资料)(2016-10-07)

经验之谈

• 一个2年安卓开发者的一些忠告 ：What 2 Years of Android Development Have Taught Me the Hard Way
• awesome-android-tips|A collections of tips in Android developing.Android开发总结

iOS 收集的高仿项目

Python制作安卓游戏外挂

　　游戏的界面是这样的：

Paste_Image.png

　　通过选择单词的意思进行攻击，选对了就正常攻击，选错了就象征性的攻击一下。玩了一段时间之后琢磨可以做成自动的，通过PIL识别图片里的单词和选项，然后翻译英文成中文意思，根据中文模糊匹配选择对应的选项。
　　查找了N多资料以后开始动手，程序用到以下这些东西：
PIL　　　　　　　Python Imaging Library 大名鼎鼎的图片处理模块
pytesser　　　　 Python下用来驱动tesseract-ocr来进行识别的模块
Tesseract-OCR 　图像识别引擎，用来把图像识别成文字，可以识别英文和中文，以及其它语言
autopy　　　　　Python下用来模拟操作鼠标和键盘的模块。

安装步骤(win7环境)：
　　(1)安装PIL，下载地址：http://www.pythonware.com/products/pil/，安装PythonImaging Library 1.1.7 for Python 2.7。
　　(2)安装pytesser，下载地址：http://code.google.com/p/pytesser/,下载解压后直接放在
C:\Python27\Lib\site-packages下，在文件夹下建立pytesser.pth文件，内容为C:\Python27\Lib\site-packages\pytesser_v0.0.1
　　(3)安装Tesseract OCR engine，下载：https://github.com/tesseract-ocr/tesseract/wiki/Downloads，下载Windows installer of tesseract-ocr 3.02.02 (including English language data)的安装文件，进行安装。
　　(4)安装语言包，在https://github.com/tesseract-ocr/tessdata下载chi_sim.traineddata简体中文语言包，放到安装的Tesseract OCR目标下的tessdata文件夹内，用来识别简体中文。
　　(5)修改C:\Python27\Lib\site-packages\pytesser_v0.0.1下的pytesser.py的函数，将原来的image_to_string函数增加语音选择参数language，language='chi_sim'就可以用来识别中文，默认为eng英文。
改好后的pytesser.py：

"""OCR in Python using the Tesseract engine from Google
http://code.google.com/p/pytesser/
by Michael J.T. O'Kelly
V 0.0.1, 3/10/07"""
 
import Image
import subprocess
import util
import errors
 
tesseract_exe_name = 'tesseract' # Name of executable to be called at command line
scratch_image_name = "temp.bmp" # This file must be .bmp or other Tesseract-compatible format
scratch_text_name_root = "temp" # Leave out the .txt extension
cleanup_scratch_flag = True  # Temporary files cleaned up after OCR operation
 
def call_tesseract(input_filename, output_filename, language):
  """Calls external tesseract.exe on input file (restrictions on types),
  outputting output_filename+'txt'"""
  args = [tesseract_exe_name, input_filename, output_filename, "-l", language]
  proc = subprocess.Popen(args)
  retcode = proc.wait()
  if retcode!=0:
    errors.check_for_errors()
 
def image_to_string(im, cleanup = cleanup_scratch_flag, language = "eng"):
  """Converts im to file, applies tesseract, and fetches resulting text.
  If cleanup=True, delete scratch files after operation."""
  try:
    util.image_to_scratch(im, scratch_image_name)
    call_tesseract(scratch_image_name, scratch_text_name_root,language)
    text = util.retrieve_text(scratch_text_name_root)
  finally:
    if cleanup:
      util.perform_cleanup(scratch_image_name, scratch_text_name_root)
  return text
 
def image_file_to_string(filename, cleanup = cleanup_scratch_flag, graceful_errors=True, language = "eng"):
  """Applies tesseract to filename; or, if image is incompatible and graceful_errors=True,
  converts to compatible format and then applies tesseract.  Fetches resulting text.
  If cleanup=True, delete scratch files after operation."""
  try:
    try:
      call_tesseract(filename, scratch_text_name_root, language)
      text = util.retrieve_text(scratch_text_name_root)
    except errors.Tesser_General_Exception:
      if graceful_errors:
        im = Image.open(filename)
        text = image_to_string(im, cleanup)
      else:
        raise
  finally:
    if cleanup:
      util.perform_cleanup(scratch_image_name, scratch_text_name_root)
  return text
 
 
if __name__=='__main__':
  im = Image.open('phototest.tif')
  text = image_to_string(im)
  print text
  try:
    text = image_file_to_string('fnord.tif', graceful_errors=False)
  except errors.Tesser_General_Exception, value:
    print "fnord.tif is incompatible filetype.  Try graceful_errors=True"
    print value
  text = image_file_to_string('fnord.tif', graceful_errors=True)
  print "fnord.tif contents:", text
  text = image_file_to_string('fonts_test.png', graceful_errors=True)
  print text

　　(6)安装autopy，下载地址：https://pypi.python.org/pypi/autopy，下载autopy-0.51.win32-py2.7.exe进行安装，用来模拟鼠标操作。

说下程序的思路：
　1. 首先是通过模拟器在WINDOWS下执行安卓的程序，然后用PicPick进行截图，将战斗画面中需要用到的区域进行测量，记录下具体在屏幕上的位置区域，用图中1来判断战斗是否开始（保存下来用作比对），用2，3，4，5，6的区域抓取识别成文字。

1485005-75900c16b01ca1f3.png

计算图片指纹的程序：

    def get_hash(self, img):
        #计算图片的hash值
        image = img.convert("L")
        pixels = list(image.getdata())
        avg = sum(pixels) / len(pixels)
        return "".join(map(lambda p : "1" if p > avg else "0", pixels))

图片识别成字符：

    #识别出对应位置图像成字符，把字符交给chose处理
    def getWordMeaning(self):
        pic_up = ImageGrab.grab((480,350, 480+300, 350+66))
        pic_aws1 = ImageGrab.grab((463,456, 463+362, 456+45))
        pic_aws2 = ImageGrab.grab((463,530, 463+362, 530+45))
        pic_aws3 = ImageGrab.grab((463,601, 463+362, 601+45))
        pic_aws4 = ImageGrab.grab((463,673, 463+362, 673+45))
 
        str_up = image_to_string(pic_up).strip().lower()
 
        #判断当前单词和上次识别单词相同，就不继续识别
        if str_up <> self.lastWord:
            #如果题目单词是英文，选项按中文进行识别
            if str_up.isalpha():
                eng_up = self.dt[str_up].decode('gbk') if self.dt.has_key(str_up) else ''
                chs1 = image_to_string(pic_aws1, language='chi_sim').decode('utf-8').strip()
                chs2 = image_to_string(pic_aws2, language='chi_sim').decode('utf-8').strip()
                chs3 = image_to_string(pic_aws3, language='chi_sim').decode('utf-8').strip()
                chs4 = image_to_string(pic_aws4, language='chi_sim').decode('utf-8').strip()
                print str_up, ':', eng_up
                self.chose(eng_up, (chs1, chs2, chs3, chs4))
            #如果题目单词是中文，选项按英文进行识别
            else:
                chs_up = image_to_string(pic_up, language='chi_sim').decode('utf-8').strip()
                eng1 = image_to_string(pic_aws1).strip()
                eng2 = image_to_string(pic_aws2).strip()
                eng3 = image_to_string(pic_aws3).strip()
                eng4 = image_to_string(pic_aws4).strip()
 
                e2c1 = self.dt[eng1].decode('gbk') if self.dt.has_key(eng1) else ''
                e2c2 = self.dt[eng2].decode('gbk') if self.dt.has_key(eng2) else ''
                e2c3 = self.dt[eng3].decode('gbk') if self.dt.has_key(eng3) else ''
                e2c4 = self.dt[eng4].decode('gbk') if self.dt.has_key(eng4) else ''
                print chs_up
                self.chose(chs_up, (e2c1, e2c2, e2c3, e2c4))
            self.lastWord = str_up
        return str_up

　　2. 对于1位置的图片提前截一个保存下来，然后通过计算当前画面和保存下来的图片的距离，判断如果小于40的就表示已经到了选择界面，然后识别2，3，4，5，6成字符，判断如果2位置识别成英文字符的，就用2解析出来的英文在字典中获取中文意思，然后再通过2的中文意思和3，4，5，6文字进行匹配，匹配上汉字最多的就做选择，如果匹配不上默认返回最后一个。之前本来考虑是用Fuzzywuzzy来进行模糊匹配算相似度的，不过后来测试了下对于中文匹配的效果不好，就改成按汉字单个进行匹配计算相似度。
匹配文字进行选择：

    #根据传入的题目和选项进行匹配选择
    def chose(self, g, chs_list):
        j, max_score = -1, 0
        same_list = None
        #替换掉题目里的特殊字符
        re_list = [u'~', u',', u'.', u';', u' ', u'a', u'V', u'v', u'i', u'n', u'【', u')', u'_', u'W', u'd', u'j', u'-', u't']
        for i in re_list:
            g = g.replace(i, '')
        print type(g)
 
        #判断2个字符串中相同字符，相同字符最多的为最佳答案
        for i, chsWord in enumerate(chs_list):
            print type(chsWord)
            l = [x for x in g if x in chsWord and len(x)>0]
            score = len(l) if l else 0
 
            if score > max_score:
                max_score = score
                j = i
                same_list = l
        #如果没有匹配上默认选最后一个
        if j ==-1:
            print '1. %s; 2. %s; 3. %s; 4. %s; Not found choice.' % (chs_list[0], chs_list[1], chs_list[2], chs_list[3])
        else:
            print '1. %s; 2. %s; 3. %s; 4. %s; choice: %s' % (chs_list[0], chs_list[1], chs_list[2], chs_list[3], chs_list[j])
            for k, v in enumerate(same_list):
                print str(k) + '.' + v,
        order = j + 1
        self.mouseMove(order)
        return order

　　３.最后通过mouseMove调用autopy操作鼠标点击对应位置进行选择。
程序运行的录像：
http://v.youku.com/v_show/id_XMTYxNTAzMDUwNA==.html
　　程序完成后使用正常，因为图片识别准确率和字典的问题，正确率约为70%左右，效果还是比较满意。程序总体来说比较简单，做出来也就是纯粹娱乐一下，串联使用了图片识别、中文模糊匹配、鼠标模拟操作，算是个简单的小外挂吧，源程序和用到的文件如下：
http://git.oschina.net/highroom/My-Project/tree/master/Word%20Hero

之前用了数个月VBS，受不了啦。听闻.py好使就试试看。 
这是用Py的第五天。 
爱搬码，非coder。 
工具：Python3.4.0 + PyCharm2016 3.2 + PyQt5.4.1 
工具：Notepad++ 
环境：Win7 
注：Notepad++写VBS时，防止代码中的中文乱码，必须设置“格式”—“以XXXX Little Endian 格式编码”。

1. 鼠标/键盘操作

从VBS过来的，先说用过的思路： 
——————————————.VBS 
请参考Demon的： 
用VBS控制鼠标（获取鼠标坐标、鼠标移动、鼠标单击、鼠标双击、鼠标右击） 
创建Excel对象，在VBA模块中调用WIN的API： 
SetCursorPos / GetCursorPos / mouse_event / keybd_event 
若要修改VBA模块中的代码，不够方便（人懒） 
——————————————.Py 
Python这边，安装对应版本的pywin32，就可调用win32api： 
（对应Python3.4.0，windows要先安装Python3.4 pywin32-2XX） 本机219 
pywin32 下载列表

# -*- coding: UTF-8 -*-
# Python version: 3.4.0
import win32api
 
def LeftClick(x, y):    # 鼠标左键点击屏幕上的坐标(x, y)
    win32api.SetCursorPos((x, y))    # 鼠标定位到坐标(x, y)
    # 注意：不同的屏幕分辨率会影响到鼠标的定位，有需求的请用百分比换算
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, x, y, 0, 0)    # 鼠标左键按下
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, x, y, 0, 0)    # 鼠标左键弹起
    # win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN + win32con.MOUSEEVENTF_LEFTUP, x, y, 0, 0)    # 测试
 
def PressOnce(x):    # 模拟键盘输入一个按键的值，键码: x
    win32api.keybd_event(x, 0, 0, 0)
 
# 测试
LeftClick(30, 30)  # 我的电脑？
PressOnce(13)  # Enter
PressOnce(9)   # TAB

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

keycode/组合键等：keybd_event使用方法

附：Python获取屏幕分辨率

import win32api
from win32api import GetSystemMetrics
def DisplaySize():
    return GetSystemMetrics(0), GetSystemMetrics(1)
 
a, b = DisplaySize()

• 1
• 2
• 3
• 4
• 5
• 6

———————————————PyUserInput 
搜到PyUserInput，好家伙，GitHub： 
PyUserInput 
（安装PyUserInput之前必须先安装对应版本的pywin32和pyHook）

2. 屏蔽鼠标键盘输入

知道了能在VBS里调用api，于是听说BlockInput可以弄到死机。 
依样画葫芦，把这句塞到VBA模块代码里去，注意换行符： 
——————————————.VBS

"Public Declare Function BlockInput Lib ""user32""  (Byval fBlock As Long) As Long " & vbCrLf & _

• 1

也该注意到了，用了user32.dll，哦也就是win的api这样。在VBS中使用：

oExcel.Run "BlockInput", True  '屏蔽鼠标键盘
wscript.Sleep 1000    '你-1s
oExcel.Run "BlockInput", False '记得解除锁定

• 1
• 2
• 3

——————————————.Py 
Python3.4用user32.dll，就是windll，直接在ctypes里

from ctypes import *
user32 = windll.LoadLibrary('user32.dll')    # 加载动态链接库
user32.BlockInput(True)   # 锁
time.sleep(1)             # 你-1s
user32.BlockInput(False)  # 该解锁啦

• 1
• 2
• 3
• 4
• 5

3. 检测/结束进程

——————————————.VBS

On Error Resume Next  
    for each ps in getobject("winmgmts:\\.\root\cimv2:win32_process").instances_
    if Ucase(ps.name)=Ucase("123.exe") then  
        ps.terminate  ' kill
        WScript.Echo "死了没"
    end if
    next 

• 1
• 2
• 3
• 4
• 5
• 6
• 7

——————————————.Py

import os
# process_name:进程名 ；返回进程个数
def process_exit(process_name):
    p_checkresp = os.popen('tasklist /fo csv | find "' + process_name + '"').readlines()
    return len(p_checkresp)
 
 
if process_exit(123.exe) == 0:    # 未检测到
    print("=0")
elif process_exit(123.exe) >= 1:    # 检测到
    command = 'taskkill /F /IM 123.exe'  # kill
    os.popen(command)    # 执行cmd命令
    # os.system(command)    # 听说用popen更好
    print("=1")
else:
    win32api.MessageBox(0, "用api弹出窗口消息")

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

4. 启动外部程序

Py和VBS都有几种方式启动外部的程序(.exe等)这里不列出了。 
VBS中运行应用程序的两种方式及WshShell对像浅析

而某些软件启动的时候会挂上其他东西… 
（非CS专业，不知道啊。是否环境变量不对、起始目录不对之类） 
wshell普通的run启动后登陆报错，用Exec也登陆后报错，各种改参数没有效果。

最后搜到个命令行用start，微软界面How to redirect command-Line output 
——————————————.VBS 
如：C:\Program Files\12345\我是中文名的程序来砍我吖.exe

WshShell.run("%comspec% /k c: & cd \Program Files\12345 & start 我是中文名的程序来砍我吖.exe&")   '稳

• 1

命令行：”%comspec% /k 
切换到程序所在盘（c:）； 
打开所在目录（cd \Program Files\12345），最后start，登陆再也没有报错！ 
注意用“&”连接每条命令，也用“&”结束。 
——————————————.Py 
CreateProcess等方法不提，本例不适用。使用CreateProcess函数运行其他程序 
Python的cmd不认cd \Program Files\12345 里边的单个反斜杠换成转义“\\\\”（四条杠）也不行。 
路径有中英文符号等等，要对字符进行判断。python利用utf-8编码判断中文英文字符(转)

# alphabet or not 是否英文字母
def is_alphabet(uchar):
        if (uchar >= u'\u0041' and uchar<=u'\u005a') or (uchar >= u'\u0061' and uchar<=u'\u007a'):
            return True
        else:
            return False
 
 
# num or not 是否数字
def is_number(uchar):
        if uchar >= u'\u0030' and uchar<=u'\u0039':
            return True
        else:
            return False
 
 
# chinese or not 是否中文
def is_chinese(uchar):
        if uchar >= u'\u4e00' and uchar<=u'\u9fa5':
            return True
        else:
            return False
 
 
# 是否非中文非英文非数字
def is_other(uchar):
        if not (is_chinese(uchar) or is_number(uchar) or is_alphabet(uchar)):
            return True
        else:
            return False

• 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

根据以上弄了个拆文件路径的玩意：

# get each dir 获得路径里每个文件夹的名字
# 传入path：文件的完整路径名+程序名
def part_path(path):
    if len(path) > 0:
        gang_arr = []       # 反斜杠位置数组
        gang_num = 0            # 反斜杠总数
        point = 0           # 点号位置
        for i in range(0, len(path)):
            if is_other(path[i]):       # 点号和反斜杠
                if path[i] == "/":      # 反斜杠
                    gang_arr.append(i)      # 每个反斜杠的位置
                    gang_num += 1
                elif path[i] == ".":
                    point = i  # 点号的位置
        # if is_alphabet(path[0]):
        #   print("disk: %s :" % path[0])
        # else:
        #   print("error disk!")
        # 每个反斜杠的位置
        # print("how many gangs = %d" % gang_num)
        # print("gang arr = %s" % str(gang_arr[0:path.count("/")]))
        # 获得每个子目录
        sub_arr = []
        for j in range(0, gang_num-1):
            sub_arr.append(path[gang_arr[j] + 1: gang_arr[j+1]])
        exe_name = path[gang_arr[gang_num-1] + 1:]
        # print("exe name: " + exe_name )   # exe name
        return path[0], exe_name, sub_arr
    else:
        win32api.MessageBox(0, "请选择文件！")
 
# 调用
disk_name, exe_name, dir_arr = part_path("C:\Program Files\12345\砍吖.exe")

• 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

（path不是随便输入的，用了PyQt中的QFileDialog获得文件路径。后面会讲） 
学着VBS用start：

# 根据反斜杠数量，多次拼接cmd命令
cmd = "cd/ & " + disk_name + ": &"
        for i in range(0, len(dir_arr)):
            cmd += "cd " + dir_arr[i] + " & "
        cmd += "start " + exe_name
        # print(cmd)
        os.popen(cmd)

• 1
• 2
• 3
• 4
• 5
• 6
• 7

5. 补充

哦，用pyInstaller3.0打包成EXE（-w -F）调试的时候，发现前面有关检测/结束/启动进程用的所有os.popen(cmd)均没反应，不执行动作，搞不清原因，于是换subprocess.Popen()，顺带发现了”cwd=”这玩意，可以指定子进程工作路径了。参考： 
Python执行系统命令：使用subprocess的Popen函数 
先用个QPushbutton挂着QFileDialog来获取文件完整路径+文件名，内容放到LineEdit（类似文本框TextBox）里：

# 首先有一个文本框（LineEdit）的名字（objectName）为tb_line1
self.tb_line1 = QLineEdit()
 
# 按钮的内容、信号连接
self.btn_fileDiaLog = self.createButton("选择客户端文件", self.showDialog)
 
# 绑定的事件
def showDialog(self):
    filename = QFileDialog.getOpenFileName(self, "选取文件","F:/","EXE Files (*.exe);;All Files (*)")
    self.tb_line1.setText(filename[0])  # content 
 
# 创建按钮用的函数
def createButton(self, text, member):
    button = QPushButton(text)
    button.clicked.connect(member)
    return button

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

# 从文本框获得文件的工作路径
exe_dir = os.path.dirname(os.path.abspath(self.tb_line1.displayText()))         
 
# 启动命令
cmd = 'start '+ exe_name
proc = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,cwd = exe_dir)
proc.stdin.write(cmd.encode())
proc.stdin.close()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

os.path.dirname(os.path.abspath(“文件名”)): 表示获取当前文件夹的所在的目录。 
Python中的绝对路径和相对路径 
比如完整文件路径：C:\Program Files\12345\砍吖.exe 
abs_path就得到：C:\Program Files\12345 
这样就不会报错啦，不用去拆文件路径的各个文件夹名。

配置之前先完成eclipse + Pydev的配置环境。详见http://www.cnblogs.com/dflower/archive/2010/05/13/1734522.html

1. 安装 wxPython 2.8　　
　　下载地址为http://sourceforge.net/projects/wxpython/files/，我用的版本是wxPython2.8-win32-unicode-2.8.10.1-py26.exe

　　建议下载 Unicode 的，用 Ansi 版的话，组件标题不能写 Unicode 字符，代码包含 Unicode 字符也会出错。安装时注意，安装路径中不能有空格。
　　
2. 下载 Boa Constructor
　　Python 拥有非常多的开发环境，也就是 IDE。但是到现在为止，能完全支持可视开发的只有 Boa Constructor。使用它可以像使用 Delphi 那样，直接拖出控件进行快速的开发。
　　下载地址为http://sourceforge.net/projects/boa-constructor/files/，目前最高版本是0.6.1　　
　　注意，Boa Constructor 的安装路径也不能有空格。

3.配置 Boa Constructor
　　打开 Boa Constructor，如果你是中文的系统，IDE 的语言会变成中文，你必须把它修改成英文的，在 工具->语言设置菜单中将它换成英文。如果使用中文的 IDE，打开，保存文件时会发生错误
　　点击 Tools->Python Interpreter Chooser，设置 Python.exe 的所在目录。
　　关闭 Boa Constructor并重新启动它，配置即告完成。

用Boa Constructor可以很方便的设计界面，具体的入门教程在最后附上。

但是在Boa里直接写代码还是比较痛苦的，可以先在eclipse里面新建一个工程，然后用Boa constructor设计好GUI保存到工程文件夹里面，再到eclipse里面刷新一下就能载入设计好的py文件，然后就可以在eclipse里面编程和调试了。

--------------------------------------------------------你飘啊飘我摇啊摇无根的分隔线-------------------------------------------------------

附：一个Boa Constructor的入门教程

1、先创建一个wx.App，这样会自动创建wx.Frame，Boa constructor就是这样设置的，我也推荐这样，先有一个app（没有Frame），然后调用其他Frame。创建方法有两种：在最上方的 Palette中的New面板下面选择wx.app；或者在Editor中选择File菜单下面的New的wx.app。 

    我们可以在Editor中看到在Shell和Explorer旁边出来一个*(App1)*和*(Frame1)*。出现*表示还没有保存。这两项下面都有子面板Source，嗯，就是代码。好了，我们先保存一下。通过File-Save保存也可以，点击那个软盘图标保存也可以。 

2、然后我们可以在Frame中添加Panel（面板）或者Button（按钮）或者TextCtrl（文本控制）。Frame是框架的意思，有框架之后就可以添加任何东西进去。最先添加进去的是一个“底板”，通常会是Panel或者Windows之类的。这种“底板”添加进去之后就会自动填充满 Frame。 

    点击Frame，然后点击Editor中的Frame Desinger图标（快捷键是F12），看见深灰色的小格子，上面还有一个标题栏对不对？这个就是Frame！现在我们就可以往其中拖拽东西了。所有可以拖拽进去的东西都在上方的Palette中，有很多的哦，比如Containers/Layout（容器/布局）、Basic Controls（基本控件）、Buttons（按钮）、List Controls（列表控件）等等等等。 

    我们在Containers/Layout中选择第一个图标wx.Panel，左键点一下，嗯，变成按下状态了。然后再Frame中点一下，Yeah~添加进去了。为什么没充满整个Frame呢？别急，先点右上角的×关掉这个Frame，再点开这个Frame（F12忘了吗？），是不是填充满了呢？都是浅灰色的了。 

（关掉重新再开——这个技巧很重要，因为只有这样Boa Constructor才能识别出来。以后我们设置属性、调整大小等等操作也最好这样“关掉重新再开”一下） 

    我们把鼠标放到Frame上，能看到panel1，放到标题栏上能看到Frame1（或者你保存Frame的名字）。这个名字也可以改，左键点击，然后看看Inspector面板中的Constr属性页，Name一项就是名字。左键点击就可以修改，千万千万别改成中文、法文、日文、韩文，只能是英文！改好之后点击上面的刷新图标（Recreate selection）。也可以改位置，在Position下面修改；也也可以改大小，在Size下面修改；也也也可以改风格，在Style下面修改。 

    （其实这还是需要wxPython方面的知识的，看看wxPython in action这本书吧，可以还是英文的） 

    Inspector下面的Props属性页下面可以该更多的东西，比如背景颜色（BackgroundColour）、提示文字（ToolTipString）、字体（Font）等等。很有用的Sizer（大小管理器）也是在这个下面设置。 

   你发没发现很多关于文字设置前面都有一个u，这是unicode的缘故。也是我们安装wxPython-unicode版本的缘故，你可以在某些提示文字之类的地方输入中文，系统会自动转换成unicdoe码。 

   （关于unicode真是很复杂！！我曾经在windows下开发，没什么问题，但是放到Linux下，傻眼！所以如果你要做跨平台软件，好好了解一下unicode） 

    Inspector下面的Evts属性页就是“事件”。所有的可能的相关事件都在这下面。鼠标事件（MouseEvent）、KeyEvent（键盘事件）等等。通过这些事件，你可以调用其他函数，并完成其他功能（比如绘图、弹出提示框、跳转到其他页面等等等等）。“事件”对于wxPython很重要，因为它是“事件驱动型GUI”（这部分你不理解就不理解吧，呵呵，记住就行了，然后在开发中慢慢理解）。 

   Inspector下面的Objs属性页给出一个树状结构，告诉你什么包含什么，你可以选择其中的一个（比如Frame1），然后查看它对应的Constr/Props/Evts。 

3、下面让我们来添加一个按钮。点击最上面Palette中的Buttons，选择第一个图标wx.Button，按下，然后在Frame中的Panel中按下，看到Button1了吧。 

    然后我们可以修改其对应的各种属性。包括大小、位置、显示文字、样式等等。在什么地方改？刚才不是告诉你了吗？在左侧的Inspector下面改。 

    为什么Boa Constructor大家都感觉很容易呢？因为有些东西是可以直接拖拽所见即所得的。比如你可以试着直接用鼠标改变按钮的大小和位置 

    其他控件也基本类似，你可以试着添加各种各样的控件进去。其实Boa Constructor不包括所有wxPython中的控件，但是它包括了基本、普通、平常、我们大家会用到的控件。所以我们可以通过Boa Constructor来入门wxPython。 

4、让我们添加一个事件（Event）。还记得我说过“事件驱动型GUI”吗？让我们“驱动”一下我们的程序吧。 

    点击选中Button，在左侧的Inspector的Evts下面单击ButtonEvent，右侧出现wx.EVT_BUTTON，双击之，在下面出现一个wx.EVT_BUTTON——OnButton1Button。好了，点击上面的“对号”。 

   保存源文件。在源文件（Source面板下面）的最下方你能看到形如：   

def OnButton1Button(self, event): 
        event.Skip() 

这样的东东。在event.Skip()前面添加你想要的代码吧，比如：print u'haha'，或者弹出一个提示面板：           

dlg = wx.MessageDialog(self,   u'yes', 
                                   u'You got it~', 
                                   wx.OK | wx.ICON_INFORMATION 
                                   ) 
dlg.ShowModal() 
dlg.Destroy() 

或者任何代码。 

（event.skip()表示将事件向下传递，你就别删它就行了） 

（我上面的弹出窗口代码其实也可以用Boa Constructor来创建一个wx.Dialog然后再调用之，但是我没有这么做，因为我觉得这样更方便。你以后也会发现更方便的一些东西，然后你会逐渐的跳出Boa Constructor了…………当然你跳不出wxPython的怀抱，呵呵） 

5、好了，万事大吉了！点击Editor页面下的Run Applictaion图标或者按下F9吧。运行下你的程序。当然，你必须在app为所选页面时才能运行程序。因为app是程序，frame不是。 

6、接下来我们可以添加其他frame，添加其他控件，添加其他module（模块），下面的路你自己走吧…… 

（我有个小建议，你试着去看一下Boa constructor的英文帮助，没有害处） 

目前我发现的Boa contructor会出现的问题： 

1、有时候Boa constructor会挂掉，只能强行关闭。通常这种情况都是程序有错误所造成的。 这个不能怪Boa constructor，你在IDLE中运行这些程序，也会假死。 有时候我也只能在命令行窗口中运行。 

2、Boa constructor不能实时刷新，我们必须点击刷新或提交按钮才能看到改动。 是的，就是这样。所以不要试图一次添加所有你能想到的东西，试着分几次来添加。 

3、中文目录的问题。 源程序文件无法运行、保存、

使用Python开发windows桌面程序

一、开发前期准备

一步步用python制作游戏外挂

上篇介绍了Python的环境搭建，主要是开发环境的介绍，本篇主要介绍Python的GUI开发工具Boa-constructor的使用和我们的程序开发完毕后的打包问题，本篇还会介绍在Python中我们如何使用第三方扩展库。

一、如何选择GUI开发工具

Python的gui开发工具有很多，有Thiner，WxPython，PyQt，pyGtk，Jython，MFC，IronPython，PythonCard，Dabo，AnyGui，Wpy等，简直有太多了，选几种用的比较多的简单介绍一下，目前我用的是WxPyton。

Tkinter

Tkinter 似乎是与tcl语言同时发展起来的一种界面库。tkinter是python的配备的标准gui库，也是opensource的产物。Tkinter可用 于windows/linux/unix/macintosh操作系统，而且显示风格是本地化的。Tkinter用起来非常简单，python自带的 IDLE就是采用它写的。除此外，tkinter的扩展集pmw和Tix功能上都要相对它强大，但tkinter却是最基本的。我认为，在用python 做gui开发，tkinter是最基本的知识，所以这个环节是必须要学习的。你或许在以后的开发中并不常用tkinter，但是一些小型的应用上面，他还 是很有用的，而且开发速度也很快。

WxPython

WxWidgets应该算是近几年了比较流行的GUI跨平台开发技术了。 wxWidgets有不同的版本应用，有c++的，也有basic的，现在在python上面也有较好的移植。wxpython的功能上面要强于 tkinter,她提供了超过200个类，面向对象的编程风格，设计的框架类似于MFC。对于大型GUI应用上面，wxPython还是具有很强的优势 的。boa constructor可以帮助我们快速可视地构建wxwidgets界面。

Jython

尝试过用python访问java类库吗，那么就用jython吧。jython其实可以认为是另外一个python开发环境，基于java的，但是大多数 的CPython调用jython下还是可以的。你可以在jython环境下像使用java一样来通过python的语法来调用java语言，真的很酷。

MFC

Windows Pywin32允许你像VC一样的形式来使用PYTHON开发win32应用。代码风格可以类似win32 sdk，也可以类似MFC，由你选择。如果你仍不放弃vc一样的代码过程在python下，那么这就是一个不错的选择。

WPY

MFC风格的Gui开发库，代码风格也类似于MFC,仅管如此，你依旧可以使用这个库来开发GUI应用，而不用担心平台移植的问题。

IronPython

如果你要想开发.net下面的应用的话，那么IronPython就是你的选择，与jython有点类似，他同样支持标准的python模块，但同样增加了 对.net库的支持。你也可以理解为他是另一个python开发环境。你可以非常方便地使用python语法进行.net应用的开发，这一点听起来真的挺 有意思。

　　上面的内容是Google找的，总之，介绍了这么多，我个人意见是，如果你是java用户，你可以选择用jython；如果你是.net用户，那么就用ironPython吧。如果你对Visual C++很熟悉，那么你可以使用MFC,WPY或是wxPython，当然我更建议wxPython了。当然，我认为对于tkinter是每一个原来搞C的 人都应该了解和学习的GUI库，因为她很轻便，小型应用就可以使用她来搞定，而对于较大型应用可以采用pyGtk,pyQt,WxPython或 PythonCard来搞定，这样的话，既可以注重知识的衔接性，也可以快速进行开发了。

二、Python扩展库

　　如果说强大的标准库奠定了python发展的基石，丰富的第三方库则是python不断发展的保证，随着python的发展一些稳定的第三库被加入到了标准库里面，可以在http://pypi.python.org/pypi?%3Aaction=index找到非常多的Python扩展库，其中下面讲的wxPython就是其中之一。我猜你喜欢Python的其中一个理由一定是它的非常多的拓展库，下面列出了常用的Python第三方库。

Django　　　　开源web开发框架，它鼓励快速开发,并遵循MVC设计，我以前用过很多次，比较好用，开发周期短。

ActiveGrid　　企业级的Web2.0解决方案。

Karrigell　　   简单的Web框架，自身包含了Web服务，py脚本引擎和纯python的数据库PyDBLite 。

webpy　　　　一个小巧灵活的Web框架，虽然简单但是功能强大 。

CherryPy　　  基于Python的Web应用程序开发框架 。

Pylons　　　　基于Python的一个极其高效和可靠的Web开发框架 。

Zope 　　　 开源的Web应用服务器。

TurboGears   基于Python的MVC风格的Web应用程序框架。

Twisted 　　  流行的网络编程库，大型Web框架。

Quixote 　　  Web开发框架。

Matplotlib　　用Python实现的类matlab的第三方库，用以绘制一些高质量的数学二维图形 。

SciPy 　　 　基于Python的matlab实现，旨在实现matlab的所有功能 。

NumPy　　　  基于Python的科学计算第三方库，提供了矩阵，线性代数，傅立叶变换等等的解决方案 。

PyGtk 　　   基于Python的GUI程序开发GTK+库。

PyQt 　　　 用于Python的QT开发库。

WxPython     Python下的GUI编程框架，与MFC的架构相似。

Tkinter 　　   Python下标准的界面编程包。

BeautifulSoup 基于Python的HTML/XML解析器，简单易用。

PIL 　　　　   基于Python的图像处理库，功能强大，对图形文件的格式支持广泛。

MySQLdb      用于连接MySQL数据库。

cElementTree高性能XML解析库，Py2.5应该已经包含了该模块，因此不算一个第三方库了。

PyGame       基于Python的多媒体开发和游戏软件开发模块。

Py2exe　　   将python脚本转换为windows上可以独立运行的可执行程序。

pefile　　     Windows PE文件解析器

三、boa-constructor的使用

我是一个.Net开发人员，我之所以不选择IronPython的原因是不想再让客户端去安装.net framework这么庞大的库，所以我选择了wxPython。wxPython的介绍上面有，我个人觉得wxPython还是比较容易学习的。因为有API可以供我们查阅，它和MFC有很多相同或者相似的地方，我个人还是比较喜欢，或者可以我没有去尝试其他的库吧，因为我发现我已经喜欢上它了。

和wxPython库搭配的开发IDE 也有很多，spe， boa-constructor，eclipse+pydev. 个人建议选择boa-constructor 和 Eclipse+Pydev 搭配。其中boa-constructor用来开发界面，Eclipse+Pydev 用来编写代码。

boa-constructor个人感觉还是非常不错的，刚开始可能会不懂，比较吃力一点，但是等你学会使用了以后相信你会喜欢上它的。下载地址：点击此处下载。  安装boa-constructor之前请确定你的机器上已经安装了wxPython 和Python。目前需要wxPython 2.4.0.7 or higher and Python 2.1 or higher.

boa-constructor 安装完毕后桌面或者开始菜单并没有它的启动快捷方式或者是目录。你需要在你的Python安装目录下找到Python26\Lib\site-packages\boa-constructor 这个路径下Boa.py文件。Boa.py为boa-constructor启动文件。

1.双击Boa.py文件加载完毕后会出现如下界面。

其中Python，wxPython, boa-constructor 的帮助文档你也会在这个工具条中找到，这几个文档能为你后面的开发工作起到很大的作用。

3. 下面的为检视器窗口，它的主要作用相当于VS中的属性窗口，包括一些控件的属性，事件等。

4. 主工作区域窗口就不进行介绍了，都是中文显示。如下图：

下面简单介绍一下如何新建工程。

1. 点击最上方工具条视图中的第五个图标。

2. 点击之后，主编辑器窗口会出来2个未保存的新建文件（*App1*,*Frame1*），其中App1为程序的启动文件，里面包含应用程序初始化的一些信息以及Main函数，Frame1为生成的一个新页面，接下面我们需要做的就是绘制界面了。

3. 切换到Frame1选项卡，然后按快捷键F12或者点击框架设计器按钮（），此时会弹出Frame1的设计界面，如下图：

4. 从工具条拖拉我们需要的控件到设计器区域，我拖拽了一个Button和一个Label，另外我修改了程序的标题。如下图：

5. WxPython也是采用的事件驱动的模型，在左边的检视器窗口我们可以看到某一个控件的信息等，包括该控件的基本属性信息，以及构造该空间所需的必须属性和可设置属性，另外还有就是该控件所拥有的事件，如下图：

6. 如何在wxPython中添加事件？其实很简单，打开检视器窗口，切换到Evts选项卡，左边菜单栏会列出该控件所具有的事件，然后右边双击就可以了，最后，别忘了对你的更改进行提交（上面对号），如下图：

7. 下面为Boa为我们生成的界面代码，我们的后台逻辑代码可以在Eclipse中利用其更好的代码提示为我们提供便利。

  1 # -*- coding: gb2312 -*-
  2 
  3 #Boa:Frame:Frame1
  4 
  5  
  6 
  7 import wx
  8 
  9  
 10 
 11 def create(parent):
 12 
 13     return Frame1(parent)
 14 
 15  
 16 
 17 [wxID_FRAME1, wxID_FRAME1BUTTON1, wxID_FRAME1LABEL1,
 18 
 19 ] = [wx.NewId() for _init_ctrls in range(3)]
 20 
 21  
 22 
 23 class Frame1(wx.Frame):
 24 
 25     def _init_ctrls(self, prnt):
 26 
 27         # generated method, don't edit
 28 
 29         wx.Frame.__init__(self, id=wxID_FRAME1, name='', parent=prnt,
 30 
 31               pos=wx.Point(426, 280), size=wx.Size(400, 250),
 32 
 33               style=wx.DEFAULT_FRAME_STYLE,
 34 
 35               title=u'\u6211\u7684\u7b2c\u4e00\u4e2aWxPython\u7a0b\u5e8f')
 36 
 37         self.SetClientSize(wx.Size(384, 212))
 38 
 39  
 40 
 41         self.Label1 = wx.StaticText(id=wxID_FRAME1LABEL1,
 42 
 43               label=u'\u6211\u559c\u6b22BOA', name=u'Label1', parent=self,
 44 
 45               pos=wx.Point(64, 24), size=wx.Size(97, 25), style=0)
 46 
 47         self.Label1.SetBackgroundColour(wx.Colour(228, 252, 230))
 48 
 49         self.Label1.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.NORMAL, False,
 50 
 51               u'\u5fae\u8f6f\u96c5\u9ed1'))
 52 
 53  
 54 
 55         self.button1 = wx.Button(id=wxID_FRAME1BUTTON1,
 56 
 57               label=u'\u70b9\u51fb\u6309\u94ae', name='button1', parent=self,
 58 
 59               pos=wx.Point(192, 24), size=wx.Size(75, 24), style=0)
 60 
 61         self.button1.Bind(wx.EVT_BUTTON, self.OnButton1Button,
 62 
 63               id=wxID_FRAME1BUTTON1)
 64 
 65  
 66 
 67     def __init__(self, parent):
 68 
 69         self._init_ctrls(parent)
 70 
 71  
 72 
 73     def OnButton1Button(self, event):
 74 
 75  
 76 
 77         fileDlg = wx.FileDialog(self,u'FileDialog',u'choose file')
 78 
 79         re = fileDlg.ShowModal()
 80 
 81         if re==5100:
 82 
 83             sr= fileDlg.GetFilename()
 84 
 85             print sr
 86 
 87             self.ShowDlg(sr)
 88 
 89             #todo:
 90 
 91         event.Skip()
 92 
 93        
 94 
 95     def ShowDlg(self,content=""):
 96 
 97         dlg = wx.MessageDialog(self,content,
 98 
 99                                    '确认框',
100 
101                                    wx.OK | wx.ICON_INFORMATION
102 
103                                    )
104 
105         dlg.ShowModal()

至此，BOA的使用简单介绍到这里，后面更多的探索还要自己去慢慢摸索。

';

  print_r($info);

 

若能打印出memcache中的信息，则说明php的memcache扩展已安装成功且能使用了！

 

注意：运行代码时若出现错误Fatal error: Class 'Memcache' not found，有可能是下载的 

      php_memcache.dll文件与php版本不符，或者与系统位数不符。

      我的是64位系统，php版本是5.5.12，下载的是php_memcache-3.0.8-5.5-ts-vc11-x64.zip

      这个文件。

 

在windows下安装运行disconf

因为作者关于disconf-web项目的部署部分说明完全基于linux，笔者本机不想装个虚拟机再装Linux，所以折腾了N长时间，还找了Java方面的相关人员帮助，好不容易才在windows上成功的部署了web项目，故而在此记录下

disconfig_web的部署说明地址为：https://github.com/knightliao/disconf/tree/master/disconf-web#how-to-deploy

必须软件安装

1、Tomcat ，下载地址：http://tomcat.apache.org/ ，安装及配置（含java）：http://jingyan.baidu.com/article/624e7459a7d6e734e9ba5a70.html

2、Nginx，下载地址：http://nginx.org/en/download.html，安装及配置：http://blog.163.com/njut_wangjian/blog/static/1657964252013327103716818/，这里因为本机已经装了IIS，所以配置上将Nginx的端口设置成了8081

3、zookeeeper，下载地址：https://zookeeper.apache.org/releases.html#download，安装及配置：中文版、英文版，这里我部署了三个服务端，配置如下：

物理结构如下：

4、mysql，本机已安装，忽略此步

5、redis，局域网服务器已安装，忽略此步

项目配置修改

此处按帮助说明修改成你实际的配置即可，这里忽略说明

将disconf-web打包成war包

因为没Linux，这里就跟文档上描述的不一样了，下载IdeaIU，安装后，在IDE中打开disconf-master下的pom.xml，当项目加载完成后，选择disconfig-web项目，在工具栏选择  Build -- Build Artifacts...，单击All，之后就是等着maven下载，以及war包生成了

生成的最终target应当如下

生成的结果看起来跟帮助说明中的不一样，但没关系，我们手工调整，先建立个war文件夹，然后分别将war包和相关文件夹从disconfig-web及生成的target下copy出来，最终结果如下，tmp文件夹可以忽略

将你修改的项目配置文件复制并覆盖 WEB-INF\classes 下的同名文件，然后修改Tomact的配置，在Host下增加Context配置，其docBase配置为你的war文件夹物理路径，举例来说我本机是配置成了 C:\\apache-tomcat-8.0.35\\webapps\\disconfig-rd\\war，注意这里反斜杠在xml中要配置成双反斜杠，Tomact端口部分我没变动，还是8080

MySql数据还原

按帮助说明一步步还原即可，此处忽略

Nginx部署

与帮助文档不同的地方在于：去掉了 upstream disconf，将listen端口设置成了8082（因为8081被我设置给了nginx自身），将root修改成了自己的物理路径，最重要的是将proxy_pass修改成了 http://127.0.0.1:8080

前言

在微服务架构中，服务发现一直是一件比较复杂的事。而且服务发现式的架构处理不好，容易产生集中化。同时，微服务的提供，不可避免的需要一些负载均衡方案，实现服务的高可用和可扩展，这无疑增加了很多复杂度。

笔者认为，使用异步、基于消息的方式，可能更适合微服务架构。

基于消息的微服务架构，对于所有微服务的部署条件非常简单，只需要能访问到消息服务即可。同时微服务节点的移除和增加不会影响到服务的提供。相比服务发现的架构，简单太多了，简单即是美。

在这次实践中，使用到了seneca，一个nodejs 微服务框架。seneca,使用seneca-amqp-transport插件，可以轻松构建基于消息的微服务。

下面是架构图：

在这个架构中，我们使用的是标准的seneca定义的命令规范，这可能是所有微服务都需要遵守的一个规范，至于说使用其他语言，也很简单。封装一个seneca命令规范的库即可。不知道官方有没开发，开发起来难度也不会太大。

接口层比较灵活，可以根据上层应用特性，来决定如何封装传输协议，最后将转化成标准命令发送到消息服务。不建议直接访问消息服务，上层应用应保持灵活。

完整的实践代码：github.com/luaxlou/mic…

1 前期准备

使用docker-machine创建虚拟机。

关于docker的一些基本用法，可以读上一篇文章：docker+consul基于服务发现的极简web架构实践，这里就不再赘述。

依次创建3台虚拟机：

$ dm create -d "virtualbox” node1
$ dm create -d "virtualbox” node2
$ dm create -d "virtualbox" node3

2 开始构建

搭建Rabbitmq消息服务

消息队列服务，已经成为高并发应用的必备基础服务。我们选用Rabbitmq，你可以换成任意的，遵循amqp协议即可。

使用docker安装很方便，但是生产环境不建议使用docker安装。更推荐的是使用云服务，这样能保证足够高的高可用和扩展性。虽然价格贵点，但是这是唯一的单点，花点钱还是值得的。

直接安装在宿主机上：

$ docker search rabbitmq
 
NAME                                       DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
rabbitmq                                   RabbitMQ is an open source multi-protocol ...   1466      [OK]
tutum/rabbitmq                             Base docker image to run a RabbitMQ server      11
frodenas/rabbitmq                          A Docker Image for RabbitMQ                     11                   [OK]
sysrun/rpi-rabbitmq                        RabbitMQ Container for the Raspberry Pi 2 ...   6
aweber/rabbitmq-autocluster                RabbitMQ with the Autocluster Plugin            5
gonkulatorlabs/rabbitmq                    DEPRECATED: See maryville/rabbitmq              5                    [OK]
letsxo/rabbitmq                            RabbitMQ with Management and MQTT plugins.      4                    [OK]
bitnami/rabbitmq                           Bitnami Docker Image for RabbitMQ               3                    [OK]

$ docker run -d --name rabbit -p   5672:5672  rabbitmq

这样就启动了一个消息队里服务，并且开放5672端口

安装jenkins

jenkins用于自动集成，不然每次构建是个很麻烦的事。

下面的实践是笔者掉了不少坑之后完成的，jenkins在安装过程中会有不少麻烦，而且在mac下安装也会遇到麻烦。

将jenkins 安装到 node1

$ dm ssh node1
 
$ mkdir /mnt/sda1/var/jenkins_home
$ sudo chown 1000 /mnt/sda1/var/jenkins_home
$ sudo chown 1000 /var/run/docker.sock
 
$ docker run -d -v /var/run/docker.sock:/var/run/docker.sock \
                -v /mnt/sda1/var/jenkins_home:/var/jenkins_home \
                -v $(which docker):/usr/bin/docker -p 8080:8080 jenkins

查看初始密码： $ cat /mnt/sda1/var/jenkins_home/secrets/initialAdminPassword

安装私有的Registry

在mac上安装即可

$ docker run -d -p 5000:5000 registry

文档参考:docs.docker.com/registry/sp…

准备代码

代码使用的是seneca官方的例子，完整的Dockerfile也已经写好。

FROM node:alpine
 
RUN npm install pm2 -g
WORKDIR /usr/src/app
 
COPY package.json ./
RUN npm install
COPY . .
 
CMD ["pm2-docker","process.yml"]

为了让nodejs能使用到多核cpu，Dockerfile 集成了pm2，使用pm2来管理node进程。

完整代码：
github.com/luaxlou/mic…

配置自动集成

这里使用了最新版的jenkins，新版的jenkins使用了pipline。一种新的构建方式,使用groovy语法。

写起来是挺优雅的，但是学习成本颇高。因为文档不全及有些文档失效，笔者不得已反编译了pipeline插件，才得以调通。

使用pipeline script

node {
    stage('Preparation') {
        def r = git('https://github.com/luaxlou/micro-service-practice.git')
   }
   stage('Build') {
       dir('seneca-listener') {
          withEnv(["DOCKER_REGISTRY_URL=http://192.168.99.1:5000"]) {
 
              docker.build("seneca-listener").push("latest")
            
          }
            
       }
               
   }
   
}

开始构建，顺利的话，会看到如下的结果：

image.png

这是pipeline的特性，可以可视化看到各个阶段的执行情况，算是不小的进步吧。

访问私有Registy的API，就可以看到生成的tag。

curl http://192.168.99.1:5000/v2/seneca-listener/tags/list

最后一步，试试我们的程序

在宿主机发布消息：

$ git clone https://github.com/luaxlou/micro-service-practice.git

seneca-clinet 代码是接口层代码的示意，可以根据自己的喜好封装。 同时直接发送了命令代码用于测试。

进入seneca-clinet 目录

$  AMQP_URL=192.168.99.1:5672 node index.js

这个程序会每隔两秒发送一个命令：

#!/usr/bin/env node
'use strict';
 
const client = require('seneca')()
    .use('seneca-amqp-transport')
    .client({
        type: 'amqp',
        pin: 'cmd:salute',
        url: process.env.AMQP_URL
    });
 
setInterval(function() {
    client.act('cmd:salute', {
        name: 'World',
        max: 100,
        min: 25
    }, (err, res) => {
        if (err) {
            throw err;
        }
        console.log(res);
});
}, 2000);

虽然一直在发命令，你很快就会发现命令全部超时了。这是因为还没有消费者，当然这些命令也没有丢失，只不过接口层没有得到及时返回。如果应用层支持异步的模式，每个command都有独立的id，可以保留id后，以后再过来取。这就很灵活了，一切看需求去封装接口层即可。

进入node2

$ docker run 192.168.99.1:5000/seneca-listener:latest
0|seneca-l | {"kind":"notice","notice":"hello seneca fwunhukrcmzn/1507605332382/16/3.4.2/-","level":"info","seneca":"fwunhukrcmzn/1507605332382/16/3.4.2/-","when":1507605332661}

启动后，回到seneca-clinet，发现之前超时的命令，全部接收到了。

{ id: 86,
  message: 'Hello World!',
  from: { pid: 16, file: 'index.js' },
  now: 1507605332699 }
{ id: 44,
  message: 'Hello World!',
  from: { pid: 16, file: 'index.js' },
  now: 1507605332701 }
{ id: 56,
  message: 'Hello World!',
  from: { pid: 16, file: 'index.js' },
  now: 1507605332703 }
{ id: 57,
  message: 'Hello World!',
  from: { pid: 16, file: 'index.js' },
  now: 1507605332706 }
{ id: 58,
  message: 'Hello World!',
  from: { pid: 16, file: 'index.js' },
  now: 1507605332707 }

至此，完整架构已经构建完毕。

一些未完的事项

1.自动集成，只需要配置webhook即可。
2.自动部署，因为docker运转的方式，当服务升级时需要重启docker进程。方式有很多，比较粗暴的是直接控制宿主机，或者类似salt这样的工具。
目前来说，没有找到太好的开源方案。个人倾向于自己开发agent，发布有限的API，用于常规的部署或者其他任务，以及可以定时收集服务器的信息，用于监控。这可能会是笔者的下一个开源项目。

总结

这篇文章算是一个新的里程碑，实践的成果将用于后期的架构。docker让我从传统的架构模式中脱离出来，同时也让我吃了不少苦头。但这一切都是值得的。

同时也是一个新的开始，终于从之前的公司出来。未来何去何从，有很多的未知，但我相信都是美好的。

这也许就是人生的魅力。

Hello World！！

Centos7 搭建最新 Nexus3 Maven 私服

Apache Maven 是一个创新的软件项目管理和综合工具。
Maven 提供了一个基于项目对象模型（POM）文件的新概念来管理项目的构建，可以从一个中心资料片管理项目构建，报告和文件。

Maven 最强大的功能就是能够自动下载项目依赖库。
Maven 提供了开发人员构建一个完整的生命周期框架。开发团队可以自动完成项目的基础工具建设，Maven 使用标准的目录结构和默认构建生命周期。
在多个开发团队环境时，Maven 可以设置按标准在非常短的时间里完成配置工作。由于大部分项目的设置都很简单，并且可重复使用，Maven 让开发人员的工作更轻松，同时创建报表，检查，构建和测试自动化设置。
Maven 项目的结构和内容在一个 XML 文件中声明，pom.xml 项目对象模型（POM），这是整个 Maven 系统的基本单元。

Maven 提供了开发人员的方式来管理：
1）Builds
2）Documentation
3）Reporting
4）Dependencies
5）SCMs
6）Releases
7）Distribution
8）mailing list
概括地说，Maven 简化和标准化项目建设过程。处理编译，分配，文档，团队协作和其他任务的无缝连接。
Maven 增加可重用性并负责建立相关的任务。
Maven 最初设计，是以简化 Jakarta Turbine 项目的建设。在几个项目，每个项目包含了不同的 Ant 构建文件。 JAR 检查到 CVS。
Apache 组织开发 Maven 可以建立多个项目，发布项目信息，项目部署，在几个项目中 JAR 文件提供团队合作和帮助。

Maven 主要目标是提供给开发人员：
1）项目是可重复使用，易维护，更容易理解的一个综合模型。
2）插件或交互的工具，这种声明性的模式。

私服介绍

私服是指私有服务器，是架设在局域网的一种特殊的远程仓库，目的是代理远程仓库及部署第三方构建。有了私服之后，当 Maven 需要下载构件时，直接请求私服，私服上存在则下载到本地仓库；否则，私服请求外部的远程仓库，将构件下载到私服，再提供给本地仓库下载。

Nexus 介绍

Nexus 是一个强大的 Maven 仓库管理器，它极大地简化了本地内部仓库的维护和外部仓库的访问。
如果使用了公共的 Maven 仓库服务器，可以从 Maven 中央仓库下载所需要的构件（Artifact），但这通常不是一个好的做法。
正常做法是在本地架设一个 Maven 仓库服务器，即利用 Nexus 私服可以只在一个地方就能够完全控制访问和部署在你所维护仓库中的每个 Artifact。
Nexus 在代理远程仓库的同时维护本地仓库，以降低中央仓库的负荷, 节省外网带宽和时间，Nexus 私服就可以满足这样的需要。
Nexus 是一套 “开箱即用” 的系统不需要数据库，它使用文件系统加 Lucene 来组织数据。
Nexus 使用 ExtJS 来开发界面，利用 Restlet 来提供完整的 REST APIs，通过 m2eclipse 与 Eclipse 集成使用。
Nexus 支持 WebDAV 与 LDAP 安全身份认证。
Nexus 还提供了强大的仓库管理功能，构件搜索功能，它基于 REST，友好的 UI 是一个 extjs 的 REST 客户端，它占用较少的内存，基于简单文件系统而非数据库。

为什么要构建 Nexus 私服？如果没有 Nexus 私服，我们所需的所有构件都需要通过 maven 的中央仓库和第三方的 Maven 仓库下载到本地，而一个团队中的所有人都重复的从 maven 仓库下载构件无疑加大了仓库的负载和浪费了外网带宽，如果网速慢的话，还会影响项目的进程。很多情况下项目的开发都是在内网进行的，连接不到 maven 仓库怎么办呢？开发的公共构件怎么让其它项目使用？这个时候我们不得不为自己的团队搭建属于自己的 maven 私服，这样既节省了网络带宽也会加速项目搭建的进程，当然前提条件就是你的私服中拥有项目所需的所有构件。

总之，在本地构建 nexus 私服的好处有：
1）加速构建；
2）节省带宽；
3）节省中央 maven 仓库的带宽；
4）稳定（应付一旦中央服务器出问题的情况）；
5）控制和审计；
6）能够部署第三方构件；
7）可以建立本地内部仓库；
8）可以建立公共仓库
这些优点使得 Nexus 日趋成为最流行的 Maven 仓库管理器。

1. 安装 jdk1.8

关于 jdk1.8 的安装, 在这里就不做赘述了

2. 安装 maven

关于 maven 的安装, 本文在这里就不详细写了

3. 安装 nexus3

1. 下载 NEXUS-3.6.0-02-UNIX.TAR.GZ

官网链接地址：www.sonatype.com/download-os… 下载 linux 最新版本，直接下载速度可能很慢，建议用迅雷下载会快很多的。

2. 解压

tar -zxvf nexus-3.6.0-02-unix.tar.gz -C /usr/local/

3. 启动 NEXUS3

cd /usr/local/nexus-3.6.0-02/bin/
./nexus run &

稍等一会 (首次启动会比较慢), 当出现以下日志的时候表示启动成功!

-------------------------------------------------
Started Sonatype Nexus OSS 3.6.0-02
-------------------------------------------------

4. 开启远程访问端口

关闭防火墙，并开启远程访问端口 8081

vim /etc/sysconfig/iptables
添加：
-A INPUT -p tcp -m state --state NEW -m tcp --dport 8081 -j ACCEPT

5. 测试

nexus3默认端口是:8081
nexus3默认账号是:admin
nexus3默认密码是:admin123

6. 设置开机自启动

ln -s /usr/local/nexus-3.6.0-02/bin/nexus /etc/init.d/nexus3
chkconfig --add nexus3
chkconfig nexus3 on

7. 修改 NEXUS3 的运行用户为 ROOT

vim nexus.rc
//设置
run_as_user="root"

8. 修改 NEXUS3 启动时要使用的 JDK 版本

vim nexus

第 14 行:

INSTALL4J_JAVA_HOME_OVERRIDE=/usr/local/java/jdk1.8.0_144

9. 修改 NEXUS3 默认端口 (可选)

cd /usr/local/nexus-3.6.0-02/etc/
vim nexus-default.properties

默认端口: 8081

application-port=8081

10. 修改 NEXUS3 数据以及相关日志的存储位置 (可选)：

[root@MiWiFi-R3-srv bin]# cd /usr/local/nexus-3.6.0-02/bin/
[root@MiWiFi-R3-srv bin]# vim nexus.vmoptions
 
-XX:LogFile=./sonatype-work/nexus3/log/jvm.log
-Dkaraf.data=./sonatype-work/nexus3
-Djava.io.tmpdir=./sonatype-work/nexus3/tmp

出现上面 5 中的测试页面，说明配置 nexus 成功！ 点击右上角 “Log in”， 输入默认用户名 (admin) 和默认密码（admin123）登录

至此, nexus3_maven 的私服就搭建完成了!!!

可以点击上面的 “设置” 图标，在 “设置” 里可以添加用户、角色，对接 LDAP 等的设置，如下：

可以在 “管理” 里查看 nexus 的系统信息

注意：

1.component name 的一些说明：
1）maven-central：maven 中央库，默认从 repo1.maven.org/maven2 / 拉取 jar
2）maven-releases：私库发行版 jar
3）maven-snapshots：私库快照（调试版本）jar
4）maven-public：仓库分组，把上面三个仓库组合在一起对外提供服务，在本地 maven 基础配置 settings.xml 中使用。

2.Nexus 默认的仓库类型有以下四种：

1）group(仓库组类型)：又叫组仓库，用于方便开发人员自己设定的仓库；
 
2）hosted(宿主类型)：内部项目的发布仓库（内部开发人员，发布上去存放的仓库）；
 
3）proxy(代理类型)：从远程中央仓库中寻找数据的仓库（可以点击对应的仓库的 Configuration 页签下 Remote Storage Location 属性的值即被代理的远程仓库的路径）；
 
4）virtual(虚拟类型)：虚拟仓库（这个基本用不到，重点关注上面三个仓库的使用）；

3.Policy(策略): 表示该仓库为发布 (Release) 版本仓库还是快照 (Snapshot) 版本仓库；

4.Public Repositories 下的仓库

1）3rd party: 无法从公共仓库获得的第三方发布版本的构件仓库，即第三方依赖的仓库，这个数据通常是由内部人员自行下载之后发布上去；

2）Apache Snapshots: 用了代理 ApacheMaven 仓库快照版本的构件仓库

3）Central: 用来代理 maven 中央仓库中发布版本构件的仓库

4）Central M1 shadow: 用于提供中央仓库中 M1 格式的发布版本的构件镜像仓库

5）Codehaus Snapshots: 用来代理 CodehausMaven 仓库的快照版本构件的仓库

6）Releases: 内部的模块中 release 模块的发布仓库，用来部署管理内部的发布版本构件的宿主类型仓库；release 是发布版本；

7）Snapshots: 发布内部的 SNAPSHOT 模块的仓库，用来部署管理内部的快照版本构件的宿主类型仓库；snapshots 是快照版本，也就是不稳定版本所以自定义构建的仓库组代理仓库的顺序为：Releases，Snapshots，3rd party，Central。也可以使用 oschina 放到 Central 前面，下载包会更快。

5.Nexus 默认的端口是 8081，可以在 etc/nexus-default.properties 配置中修改。

6.Nexus 默认的用户名密码是 admin/admin123

• 当遇到奇怪问题时，重启 nexus，重启后 web 界面要 1 分钟左右后才能访问。

8.Nexus 的工作目录是 sonatype-work（路径一般在 nexus 同级目录下）

[root@master-node local]# pwd
/usr/local
[root@master-node local]# ls nexus/
bin deploy etc lib LICENSE.txt NOTICE.txt public system
[root@master-node local]# ls sonatype-work/
nexus3
[root@master-node local]# ls sonatype-work/nexus3/
backup blobs cache db elasticsearch etc generated-bundles health-check instances keystores lock log orient port tmp

Nexus 仓库分类的概念：

1）Maven 可直接从宿主仓库下载构件, 也可以从代理仓库下载构件, 而代理仓库间接的从远程仓库下载并缓存构件

2）为了方便, Maven 可以从仓库组下载构件, 而仓库组并没有时间的内容 (下图中用虚线表示, 它会转向包含的宿主仓库或者代理仓库获得实际构件的内容).

Nexus 的 web 界面功能介绍

1.BROWSE SERVER CONTENT

1.1 Search

这个就是类似 Maven 仓库上的搜索功能，就是从私服上查找是否有哪些包。

注意：

1）在 Search 这级是支持模糊搜索的，如图所示：

2）如果进入具体的目录，好像不支持模糊搜索，如图所示：

1.2 Browse

1）Assets
这是能看到所有的资源，包含 Jar，已经对 Jar 的一些描述信息。
2）Components
这里只能看到 Jar 包。

2.SERVER ADMINSTRATION AND CONFIGURATION

看到这个选项的前提是要进行登录的，如上面已经介绍登陆方法，右上角点击 “Sign In” 的登录按钮，输入 admin/admin123, 登录成功之后，即可看到此功能，如图所示：

2.1 Blob Stores

文件存储的地方，创建一个目录的话，对应文件系统的一个目录，如图所示：

2.2 Repositories

1）Proxy

这里就是代理的意思，代理中央 Maven 仓库，当 PC 访问中央库的时候，先通过 Proxy 下载到 Nexus 仓库，然后再从 Nexus 仓库下载到 PC 本地。

这样的优势只要其中一个人从中央库下来了，以后大家都是从 Nexus 私服上进行下来，私服一般部署在内网，这样大大节约的宽带。

创建 Proxy 的具体步骤

1 点击 “Create Repositories” 按钮

2 选择要创建的类型

3 填写详细信息

Name：就是为代理起个名字

Remote Storage: 代理的地址，Maven 的地址为: repo1.maven.org/maven2/

Blob Store: 选择代理下载包的存放路径

2）Hosted

Hosted 是宿主机的意思，就是怎么把第三方的 Jar 放到私服上。

Hosted 有三种方式，Releases、SNAPSHOT、Mixed

Releases: 一般是已经发布的 Jar 包

Snapshot: 未发布的版本

Mixed：混合的

Hosted 的创建和 Proxy 是一致的，具体步骤和上面基本一致。如下：

注意事项：

Deployment Pollcy: 需要把策略改成 “Allow redeploy”。

3）Group能把两个仓库合成一个仓库来使用，目前没使用过，所以没做详细的研究。

2.3 Security这里主要是用户、角色、权限的配置（上面已经提到了在这里添加用户和角色等）

2.4 Support

包含日志及数据分析。

2.5 System
主要是邮件服务器，调度的设置地方
这部分主要讲怎么和 Maven 做集成, 集成的方式主要分以下种情况：代理中央仓库、Snapshot 包的管理、Release 包的管理、第三方 Jar 上传到 Nexus 上。

代理中央仓库

只要在 PMO 文件中配置私服的地址（比如 http://192.168.1.14:8081）即可，配置如下：

<repositories>
	<repository>
		<id>maven-central</id>
		<name>maven-central</name>
		<url>http://192.168.1.14:8081/repository/maven-central/</url>
		<snapshots>
			<enabled>true</enabled>
		</snapshots>
		<releases>
			<enabled>true</enabled>
		</releases>
	</repository>
</repositories>

SNAPSHOT 包的管理

1）修改 Maven 的 settings.xml 文件，加入认证机制

<servers>
	<server><id>nexus</id>
	<username>admin</username>
	<password>admin123</password>
</server>

2）修改工程的 Pom 文件

<distributionManagement>
	<snapshotRepository>
		<id>nexus</id>
		<name>Nexus Snapshot</name>
		<url>http://192.168.1.14:8081/repository/maven-snapshots/</url>
	</snapshotRepository>
	<site>
		<id>nexus</id>
		<name>Nexus Sites</name>
		<url>dav:http://192.168.1.14:8081/repository/maven-snapshots/</url>
	</site>
</distributionManagement>

注意事项:

上面修改的 Pom 文件如截图中的名字要跟 / usr/local/maven/conf/settings.xml 文件中的名字一定要对应上。

3）上传到 Nexus 上

1– 项目编译成的 jar 是 Snapshot(POM 文件的头部)

<groupId>com.zhisheng</groupId>
<artifactId>test-nexus</artifactId>
<version>1.0.0-SHAPSHOT</version>
<packaging>jar</packaging>

2– 使用 mvn deploy 命令运行即可（运行结果在此略过）

3– 因为 Snapshot 是快照版本，默认他每次会把 Jar 加一个时间戳，做为历史备份版本。

RELEASES 包的管理

1）与 Snapshot 大同小异，只是上传到私服上的 Jar 包不会自动带时间戳2）与 Snapshot 配置不同的地方，就是工程的 PMO 文件，加入 repository 配置

<distributionManagement>
	<repository>
		<id>nexus</id>
		<name>Nexus Snapshot</name>
		<url>http://192.168.1.14:8081/repository/maven-releases/</url>
	</repository>
</distributionManagement>

3）打包的时候需要把 Snapshot 去掉

<groupId>com.zhisheng</groupId>
<artifactId>test-nexus</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging> |

第三方 JAR 上传到 NEXUS

[root@master-node src]# mvn deploy:deploy-file -DgroupId=org.jasig.cas.client -DartifactId=cas-client-core -Dversion=3.1.3 -Dpackag
注意事项：
-DrepositoryId=nexus 对应的就是 Maven 中 settings.xml 的认证配的名字
。