• 电脑入门学习-入门学习-汉字输入法2（电脑入门学打字教学全集视频）
• c# 多线程 —— 入门学习
• c#入门学习笔记
• C++ 入门学习笔记
• C++介绍与入门学习

电脑入门学习-入门学习-汉字输入法2（电脑入门学打字教学全集视频）

c# 多线程 —— 入门学习

1. 概念介绍

1.1 线程

　　线程是操作系统能够进行运算调度的最小单位，包含在进程之中，是进程中的实际运作单位。一条线程指的时进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。.NET 中 System.Thread 下可以创建线程。

1.2 主线程

　　每个 windows 进程都包含一个用做程序入口点的主线程。进程入口点（main 方法）中创建的第一个线程称为主线程，调用 main 方法时，主线程被创建。　

1.3 前台线程

　　默认情况下，Thread.Start () 方法创建的线程都是前台线程，属性 isBackground=true/false 能够设置线程的线程是否为后台线程。前台线程能阻止应用程序的终结，只有所有的前台线程执行完毕，CLR（Common Language Runtime，公共语言运行库）才能关闭应用程序。前台线程属于工作者线程。

1.4 后台线程

　　后台线程通过 isBackground 设置，它不会影响应用程序的终结，当所有前台线程执行完毕后，后台线程无论是否执行完毕，都会被终结。一般后台线程用来做无关紧要的任务（如邮箱天气更新等），后台线程也属于工作者线程。

2. 多线程实现

2.1 创建线程

　　在 VS2019 中，建立一个控制台应用程序，测试多线程服务。首先开启 2 个线程 workThread、printThread，分别实现数字计数、打印字母。代码实现如下：

　　 class Program
    {
        static void Main(string[] args)
        {
            //新建两个线程，单独运行
            Thread workThread=new Thread(NumberCount);
            Thread printThread=new  Thread(printNumber);
            workThread.Start();
            printThread.Start();
            Console.WriteLine("Hello World!");
        }

        public static void NumberCount()
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("the number is {0}",i);
            }
        }

        public static void printNumber()
        {
            for (char i = ''A''; i < ''J''; i++)
            {

                Console.WriteLine("print character {0}", i);
            }
        }
    }

运行结果如下：

　　 根据上述运行结果可以看出，主线程 workThread 和其他线程 printThread 运行时相互独立，互不干扰。

2.2  线程基本属性了解

　　　　static void Main(string[] args)
        {
            Thread th = Thread.CurrentThread;//访问当前正在运行的线程
            bool aliveRes=th.IsAlive;//当前线程的执行状态
            Console.WriteLine("IsAlive= {0}", aliveRes);
            th.IsBackground =false;//线程是否为后台线程
            Console.WriteLine("IsBackground= {0}", th.IsBackground);
            bool isPool= th.IsThreadPoolThread;//当前线程是否属于托管线程池
            Console.WriteLine("isPool= {0}", isPool);
            int sysbol = th.ManagedThreadId;//获取当前托管线程的唯一标识
            Console.WriteLine("ManagedThreadId= {0}", sysbol);
            ThreadPriority pry=th.Priority;//设置线程调度优先级
            Console.WriteLine("pry= {0}", pry);
            ThreadState state=th.ThreadState;//获取当前线程状态值
            Console.WriteLine("state= {0}", state);
            th.Name = "main thread";
            Console.WriteLine("this is {0}",th.Name);
            Console.ReadKey();
            Console.WriteLine("Hello World!");
        }

2.3 暂停线程

　　暂停线程通过调用 sleep () 方法实现，使得线程暂停但不占用计算机资源，实现代码如下：

　　　　static void NumberCountCouldDelay()
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("the number is {0}", i);
                Thread.Sleep(TimeSpan.FromSeconds(1));
            }
        }
        public static void printNumber()
        {
            for (char i = ''A''; i < ''J''; i++)
            {
                Console.WriteLine("print character {0}", i);
                Thread.Sleep(TimeSpan.FromSeconds(1));
            }
        }

运行结果如下：

2.4 线程池

　　线程池是一种多线程处理形式，将任务添加到队列，然后再创建线程后自动启动这些任务。通过线程池创建的任务属于后台任务，每个线程使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件），则线程池将插入另一个辅助线程来使所有的处理器保持繁忙。

实现代码及运行结果如下：

　　　　static void Main(string[] args)
        {
            Console.WriteLine("this is main thread: ThreadId={0}", Thread.CurrentThread.ManagedThreadId);
            ThreadPool.QueueUserWorkItem(printNumber);
            ThreadPool.QueueUserWorkItem(Go);
            Console.Read();
        }
       
        public static void printNumber(object data)
        {
            for (char i = ''A''; i < ''D''; i++)
            {
                Console.WriteLine("print character {0}", i);
                Console.WriteLine("the print process threadId is {0}", Thread.CurrentThread.ManagedThreadId);
            }
        }
        public static void Go(object data)
        {
            Console.Write("this is another thread:ThreadId={0}",Thread.CurrentThread.ManagedThreadId);
        }

2.5 中止线程

　　线程中止采用 abort 方法，实现如下：

static void Main(string[] args)
        {
            ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Creating the child thread");
            Thread childThread = new Thread(childref);//创建线程，扩展的Thread类
            childThread.Start();//调用start()方法开始子线程的执行
            //停止主线程一段时间
            Thread.Sleep(2000);
            //现在中止子线程
            Console.WriteLine("In Main: Abort the child thread");
            childThread.Abort();
            Console.WriteLine("Hello World!");
        }
        public static void CallToChildThread()
        {
            try
            {
                //调用abort()方法销毁线程
                Console.WriteLine("Child thread start");
                for (int counter=0; counter<=10;counter++)
                {
                    Thread.Sleep(500);
                    Console.WriteLine(counter);
                }
                Console.WriteLine("child thread abort");
            }
            catch (ThreadAbortException e)
            {
                Console.WriteLine(e);
                throw;
            }
            finally
            {
                Console.WriteLine("Couldn''t catch the Thread Exception");
            }
        }

　　运行程序，出现如下错误：

　　经查找，发现.NET CORE 平台不支持线程中止，在调用 abort 方法时会抛出 ThreadAbortException 异常。

2.5 跨线程访问

　　新建一个 winform 窗体应用程序，实现点击按钮为 textbox 赋值，代码如下：

private void Button1_Click(object sender, EventArgs e)
        {
            Thread thread=new Thread(test);
            thread.IsBackground = true;
            thread.Start();
            Console.ReadLine();
        }

        private void test()
        {
            for (int i = 0; i < 10; i++)
            {
                this.textBox1.Text = i.ToString();
            }
        }

　　然而，运行时出现以下错误，内容显示 “线程间操作无效：从不是创建控件 textBox1 的线程访问它”。是因为控件 textBox1 是由主线程创建的，thread 作为另外一个线程，在.NET 上执行的是托管代码，c# 强制要求代码线程安全，不允许跨线程访问。

　　上述问题解决办法如下：(参考 https://docs.microsoft.com/en-us/dotnet/framework/winforms/controls/how-to-make-thread-safe-calls-to-windows-forms-controls)

 　　利用委托实现回调机制，回调过程如下：

　　（1）定义并声明委托；

　　（2）初始化回调方法；

　　（3）定义回调使用的方法

public partial class UserControl1: UserControl
    {
        private delegate void SetTextboxCallBack(int value);//定义委托

        private SetTextboxCallBack setCallBack;

        /// <summary>
        ///定义回调使用的方法
        /// </summary>
        /// <param name="value"></param>
        private void SetText(int value)
        {
            textBox1.Text = value.ToString();
        }
       public UserControl1()
        {
            InitializeComponent();
        }
        private void Button1_Click(object sender, EventArgs e)
        {
            //初始化回调函数
            setCallBack=new SetTextboxCallBack(SetText);
            //创建一个线程去执行这个回调函数要操作的方法
            Thread thread = new Thread(test);
            thread.IsBackground = true;
            thread.Start();
            Console.ReadLine();
        }
        public void test()
        {
            for (int i = 0; i < 10; i++)
            {
                //控件上执行回调方法，触发操作
                textBox1.Invoke(setCallBack,i);
            }
        }
  }        

运行结果如下：

2.5 多线程使用委托

　　线程的创建通过 new Thread 来实现，c# 中该构造函数的实现有以下 4 种：

• public Thread(ThreadStart start){}
• public Thread(ParameterizedThreadStart start){}
• public Thread(ThreadStart start, int maxStackSize){}
• public Thread(ParameterizedThreadStart start, int maxStackSize){}

其中，参数 ThreadStart 定义为：

public delegate void ThreadStart();//无参数无返回值的委托

参数 ParameterizedThreadStart 定义为：

public delegate void ParameterizedThreadStart(object obj);//有参数无返回值的委托

因此，对无返回值的委托实现如下。

2.5.1 无参数无返回值的委托

　　对于无参数无返回值的委托，是最简单原始的使用方法。Thread thread= new Thread (new ThreadStart (()=> 参数)，其中参数为 ThreadStart 类型的委托。此类多线程代码实现如下：

class Program
    {
        public delegate void ThreadStart();//新建一个无参数、无返回值的委托
        static void Main(string[] args)
        {
            Thread thread=new Thread(new System.Threading.ThreadStart(NumberCount));
            thread.IsBackground = true;
            thread.Start();
            for (char i = ''A''; i < ''D''; i++)
            {
                Console.WriteLine("print character {0},the threadId id ={1}", i, Thread.CurrentThread.ManagedThreadId);
            }
            Console.WriteLine("Hello World!");
        }

        public static void NumberCount()
        {
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine("the number is {0},the threadId id ={1}", i, Thread.CurrentThread.ManagedThreadId);
            }
        }
    }

2.5.2 有参数无返回值的委托

　　对于有参数无返回值的委托，实现代码如下：

class Program
    {
        public delegate void ThreadStart(int i);//新建一个无参数、无返回值的委托
        static void Main(string[] args)
        {
            Thread thread=new Thread(new ParameterizedThreadStart(NumberCount));
            thread.IsBackground = true;
            thread.Start(3);
            for (char i = ''A''; i < ''D''; i++)
            {
                Console.WriteLine("print character {0},the threadId id ={1}", i, Thread.CurrentThread.ManagedThreadId);
            }
            Console.WriteLine("Hello World!");
        }

        public static void NumberCount(object i)
        {
           Console.WriteLine("the number is {0},the threadId id ={1}", i, Thread.CurrentThread.ManagedThreadId);
        }

    }

运行结果为：

2.5.2 有参数有返回值的委托

 　　对于有参数有返回值的委托，采用异步调用实现，如下所示：

2.6 异步实现

2.6.1 Task.Result

 　　..NET 中引入了 System.Threading.Tasks，简化了异步编程的方式，而不用直接和线程、线程池打交道。　System.Threading.Tasks 中的类型被称为任务并行库（TPL)，TPL 使用 CLR 线程池（TPL 创建的线程都是后台线程）自动将应用程序的工作动态分配到可用的 CPU 的中。

　　Result 方法可以返回 Task 执行后的结果。但是在.NET CORE 的 webapi 中使用 result 方法来获取 task 的输出值，会造成当前 API 线程阻塞等待到 task 执行完成后再继续。以下代码中，get 方法中的线程 id-57, 调用一个新线程执行 task 后，等待 TaskCaller () 执行结果（threadid=59）, 待 TaskCaller () 方法执行完成后，原来的线程继续之后之后的语句，输出 threadid=57

　　public class ValuesController:Controller
    {
        //async/await是用来进行异步调用的形式，
        [HttpGet("get")]
        public async Task<string> Get()
        {
            var info = string.Format("api执行线程{0}",Thread.CurrentThread.ManagedThreadId);//get方法中的线程
            //调用新线程执行task任务
            var infoTask = TaskCaller().Result;//调用result方法获取task的值
            var infoTaskFinished = string.Format("api执行线程(taks调用completed){0}", Thread.CurrentThread.ManagedThreadId);
            return string.Format("{0},{1},{2}", info, infoTask, infoTaskFinished);
        }
        public async Task<string> TaskCaller()
        {
            await Task.Delay(5000);
            return string.Format("task 执行线程{0}", Thread.CurrentThread.ManagedThreadId);
        }
    }

运行结果如下：

 2.6.2 Async&Await

　　c# 中 async 关键字用来指定方法，Lambda 表达式或匿名方法自动以异步的方式来调用。async/await 是用来进行异步调用的形式，内部采用线程池进行管理。如果使用 await，在调用 await tasjCall () 是不会阻塞 get 方法的主线程，主线程会被释放，新的线程执行完 task 后继续执行 await 后的代码，从而减少了线程切换的开销，而之前的线程则空闲了。

public class ValuesAwaitController : Controller
    {
        [HttpGet("get")]
        public async Task<string> Get()
        {
            var info = string.Format("api执行线程{0}",Thread.CurrentThread.ManagedThreadId);//get方法中的线程
            //调用新线程执行task任务
            var infoTask = await TaskCaller();//使用await调用不会阻塞Get()中线程
            var infoTaskFinished = string.Format("api执行线程(taks调用completed){0}", Thread.CurrentThread.ManagedThreadId);
            return string.Format("{0},{1},{2}", info, infoTask, infoTaskFinished);
        }
        public async Task<string> TaskCaller()
        {
            await Task.Delay(5000);
            return string.Format("task 执行线程{0}", Thread.CurrentThread.ManagedThreadId);
        }
    }

运行结果如下：

 　　Task.result 与 await 关键字具有类似的功能可以获取到任务的返回值，但本质上 Task.result 会让外层函数执行线程阻塞知道任务完成，而使用 await 外层函数线程不会阻塞，而是通过任务执行线程来执行 await 后的代码。

• 默认创建的 Thread 是前台线程，创建的 Task 为后台线程；
• ThreadPool 创建的线程都是后台线程；
• 任务并行库 (TPL) 使用的是线程池计数；
• 调用 async 标记的方法，刚开始是同步执行，只有当执行到 await 标记的方法中的异步任务时，才会挂起。

c#入门学习笔记

C++ 入门学习笔记

1、C++ 11 以前的版本，嵌套 vector 的尖括号，右尖括号之间需要留空格

std::vecotr<std::vector<int> >

C++介绍与入门学习

C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计，因而C++就适应的问题规模而论，大小由之。

C++不仅拥有计算机高效运行的实用性特征，同时还致力于提高大规模程序的编程质量与程序设计语言的问题描述能力。

免费教程链接：C++ 入门教程（开发文档）

语言特点：

支持数据封装和数据隐藏

在C++中，类是支持数据封装的工具，对象则是数据封装的实现。C++通过建立用户定义类支持数据封装和数据隐藏。

在面向对象的程序设计中，将数据和对该数据进行合法操作的函数封装在一起作为一个类的定义。对象被说明为具有一个给定类的变量。每个给定类的对象包含这个类所规定的若干私有成员、公有成员及保护成员。完好定义的类一旦建立，就可看成完全封装的实体，可以作为一个整体单元使用。类的实际内部工作隐藏起来，使用完好定义的类的用户不需要知道类是如何工作的，只要知道如何使用它即可。

支持继承和重用

在C++现有类的基础上可以声明新类型，这就是继承和重用的思想。通过继承和重用可以更有效地组织程序结构，明确类间关系，并且充分利用已有的类来完成更复杂、深入的开发。新定义的类为子类，成为派生类。它可以从父类那里继承所有非私有的属性和方法，作为自己的成员。

支持多态性

采用多态性为每个类指定表现行为。多态性形成由父类和它们的子类组成的一个树型结构。在这个树中的每个子类可以接收一个或多个具有相同名字的消息。当一个消息被这个树中一个类的一个对象接收时，这个对象动态地决定给予子类对象的消息的某种用法。多态性的这一特性允许使用高级抽象。

继承性和多态性的组合，可以轻易地生成一系列虽然类似但独一无二的对象。由于继承性，这些对象共享许多相似的特征。由于多态性，一个对象可有独特的表现方式，而另一个对象有另一种表现方式。

工作原理编辑

C++语言的程序因为要体现高性能，所以都是编译型的。但其开发环境，为了方便测试，将调试环境做成解释型的。即开发过程中，以解释型的逐条语句执行方式来进行调试，以编译型的脱离开发环境而启动运行的方式来生成程序最终的执行代码。[9]

生成程序是指将源码（C++语句）转换成一个可以运行的应用程序的过程。如果程序的编写是正确的，那么通常只需按一个功能键，即可搞定这个过程。该过程实际上分成两个步骤。

第一步是对程序进行编译，这需要用到编译器（compiler）。编译器将C++语句转换成机器码(也称为目标码)；如果这个步骤成功，下一步就是对程序进行链接，这需要用到链接器（linker）。链接器将编译获得机器码与C++库中的代码进行合并。C++库包含了执行某些常见任务的函数（“函数”是子程序的另一种称呼）。例如，一个C++库中包含标准的平方根函数sqrt，所以不必亲自计算平方根。C++库中还包含一些子程序，它们把数据发送到显示器，并知道如何读写硬盘上的数据文件。

语言评价：

C++是在C语言的基础上开发的一种面向对象编程语言，应用非常广泛。常用于系统开发，引擎开发等应用领域，支持类、封装、继承、多态等特性。C++语言灵活，运算符的数据结构丰富、具有结构化控制语句、程序执行效率高，而且同时具有高级语言与汇编语言的优点。

C++语言是对C语言的扩充，从Simula中吸取了类，从ALGOL语言中吸取了运算符的一名多用、引用和在分程序中任何位置均可说明变量，综合了Ada语言的类属和Clu语言的模块特点，形成了抽象类，从Ada Clu和ML等语言吸取了异常处理，从BCPL语言中吸取了用//表示注释C++语言保持了C语言的紧凑灵活、高效以及易于移植性强等优点，它对数据抽象的支持主要在于类概念和机制，对面向对象风范的支持主要通过虚拟机制函数因C++语言既有数据抽象和面向对象能力，运行性能高，加上C语言的普及，而从C语言到C++语言的过渡较为平滑，以及C++语言与C语言的兼容程度可使数量巨大的C语言程序能方便地在C++语言环境中复用，使C++语言在短短几年内能流行。

免费C++ 入门教程：阿里云大学—开发者课堂

今天的关于电脑入门学习-入门学习-汉字输入法2和电脑入门学打字教学全集视频的分享已经结束，谢谢您的关注，如果想了解更多关于c# 多线程 —— 入门学习、c#入门学习笔记、C++ 入门学习笔记、C++介绍与入门学习的相关知识，请在本站进行查询。

以上就是给各位分享电脑入门学习-多媒体学习-internet学习01，其中也会对多媒体教学电脑进行解释，同时本文还将给你拓展(已导出)【kubernetes系列学习】client-go学习与实践、.net学习笔记之 AJAX学习、.NET开发人员关于ML.NET的入门学习、Android多媒体学习等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

• 电脑入门学习-多媒体学习-internet学习01（多媒体教学电脑）
• (已导出)【kubernetes系列学习】client-go学习与实践
• .net学习笔记之 AJAX学习
• .NET开发人员关于ML.NET的入门学习
• Android多媒体学习

电脑入门学习-多媒体学习-internet学习01（多媒体教学电脑）

电脑技术网教你学电脑入门学习系列视频教程适合刚学电脑的朋友，讲的很简单易懂。对刚学电脑的朋友是比较有帮助的，能快速引导你学习电脑入门知识。看完这一系列教程，基本上对电脑操作知识有了大概的了解，让你知道可以从哪里入手操作电脑。已经有一定电脑知识的朋友可以跳过此教程。

(已导出)【kubernetes系列学习】client-go学习与实践

【kubernetes系列学习】client-go学习与实践

release author: ningan123

release time: 2022-08-09

client-go客户端对象

client-go支持RESTClient、ClientSet、Dynamicclient、discoveryClient四种客户端与Kubernetes Api Server进行交互。

• RESTClient：最基础的客户端，主要是对HTTP请求进行了封装，支持Json和Protobuf格式的数据。

• discoveryClient：发现客户端，负责发现APIServer支持的资源组、资源版本和资源信息的(GVR)。

• ClientSet：负责操作Kubernetes内置的资源对象，例如：Pod、Services等。

• Dynamicclient：动态客户端，可以对任意的Kubernetes资源对象进行通用操作，包括CRD。

client-go-demo 工程初始化

[root@master ~]# mkdir client-go-demo
[root@master ~]#
[root@master ~]#
[root@master ~]# cd client-go-demo/
[root@master client-go-demo]#
[root@master client-go-demo]# ll
总用量 0
[root@master client-go-demo]#
[root@master client-go-demo]#
[root@master client-go-demo]# go mod init ningan.com/client-go-demo
go: creating new go.mod: module ningan.com/client-go-demo
[root@master client-go-demo]#
[root@master client-go-demo]# ll
总用量 4
-rw-r--r-- 1 root root 42 8月   9 04:06 go.mod
[root@master client-go-demo]#
[root@master client-go-demo]# cat go.mod
module ningan.com/client-go-demo

go 1.17

RESTClient

RESTClient是最基础的客户端，其他的ClientSet、Dynamicclient即DscoveryClient都是基于RESTClient实现的。

RESTClient对HTTP Client进行了封装，实现了Restful风格的API。

它具有很高的灵活性，数据不依赖于方法和资源，因此RESTClient能够处理多种类型的调用，返回不同的数据格式。

demo示例：通过RESTClient示例列出某一命名空间下的Pod资源对象

package main

import (
	"context"
	"fmt"

	corev1 "k8s.io/api/core/v1"
	Metav1 "k8s.io/apimachinery/pkg/apis/Meta/v1"
	"k8s.io/client-go/kubernetes/scheme"
	"k8s.io/client-go/rest"
	"k8s.io/client-go/tools/clientcmd"
)

/*
	@Author: ningan
	@Desc: 获取kube-system命名空间下的Pod列表
*/

func main() {
	/*
		1. k8s的配置文件
		2. 保证开发机能通过这个配置文件连接到k8s集群
	*/

	// 1. 加载配置文件，生成config对象
	config, err := clientcmd.BuildConfigFromFlags("", "/root/.kube/config")
	if err != nil {
		panic(err)
		// panic(err.Error())
	}

	// 2. 配置API路径  请求的HTTP路径
	config.APIPath = "api" // pods,  /api/v1/pods
	// config.APIPath = "apis" // deployments,  /apis/apps/v1/namespaces/{namespace}/deployments/{deployment}

	// 3. 配置请求的资源组/资源版本 GV
	config.GroupVersion = &corev1.SchemeGroupVersion // 无名资源组, group: " ", version: "v1"

	// 4. 配置数据的编解码工具  序列化和反序列化
	config.NegotiatedSerializer = scheme.Codecs

	// 5. 通过kubeconfg配置信息实例化RESTClient对象
	restClient, err := rest.RESTClientFor(config)
	if err != nil {
		panic(err)
	}

	// 6. 定义接收返回值的变量
	result := &corev1.PodList{}

	// 跟APIServer交互
	err = restClient.
		Get().                                                                  // RESTClient对象构建HTTP请求参数  请求方法：Get、Post、Put、Delete、Patch
		Namespace("kube-system").                                               // 命名空间
		Resource("pods").                                                       // 资源名
		VersionedParams(&Metav1.ListOptions{Limit: 50}, scheme.ParameterCodec). // 将一些查询选项(如limit、TimeoutSeconds)添加到请求参数中 limit参数表示最多检索出多少信息
		Do(context.Todo()).                                                     // 执行该请求
		Into(result)                                                            // 将kube-apiserver返回的结果（Result对象）解析到corev1.PodList对象中
	if err != nil {
		panic(err)
	}

	/*
		1）Get定义请求方式，返回了一个Request结构体对象。这个Request结构体对象，就是构建访问APIServer用的。
		2）依次执行了Namespace、Resource、VersionedParams，构建与APIServer交互的参数。
		3）Do方法通过requets发起请求，然后通过transformResponse解析请求返回，并绑定到对应资源对象的结构体对象上。这里的话，表示的是corev1.PodList对象。
		4）request先是检查了有没有可用的client，在这里开始调用net/Http包的功能。
	*/

	/*
		1) RESTClient发送请求的过程对Go语言标准库net/http进行了封装，由Do -> Request函数实现。
		2) 请求发送之前需要根据请求参数生成请求的RESTful URL，由r.URL().String()函数完成。 http://xxxx:x/api/v1/namespaces/kube-system/pods?limit=1
		3) 通过Go语言标准库net/http向RESTful URL(即kube-apiserver)发送请求，请求得到的结果存放在http.Response的Body对象中，fn函数（即transformResponse）将结果转化为资源对象。
	*/

	// 格式化输出结果
	for _, item := range result.Items {
		fmt.Printf("namespace: %v, name: %v, status: %v\n", item.Namespace, item.Name, item.Status.Phase)
	}
}

运行：

[root@master demo1]# go run main.go
namespace: kube-system, name: calico-kube-controllers-67878b879f-2x5xg, status: Running
namespace: kube-system, name: calico-node-4xwrz, status: Running
namespace: kube-system, name: metrics-server-68955dc6f-xvv9t, status: Running

ClientSet

RESTClient是一张最基础的客户端，使用时需要指定Resource和Version等信息，编写代码需要提前知道Resource所在的Group和对应的Version信息。

相比RESTClient，ClientSet使用起来更加便捷，一般情况下，开发者对Kubernetes进行二次开发时通常使用ClientSet。

ClientSet在RESTClient的基础上封装了对Resource和Version的管理方法。每一个Resource可以理解为一个客户端，而ClientSet则是多个客户端的几核，每一个Resource和Version都以函数的方法暴露给开发者，例如ClientSet提供的RbacV1、CoreV1、NetworkingV1等接口参数。

demo示例：通过ClientSet示例列出某一命名空间下的Pod资源对象

package main

import (
	"context"
	"fmt"

	Metav1 "k8s.io/apimachinery/pkg/apis/Meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"
)

/*
	@Author: ningan
	@Desc: 获取kube-system命名空间下的Pod列表
*/

func main() {
	// 1. 加载配置文件，生成config对象
	config, err := clientcmd.BuildConfigFromFlags("", "/root/.kube/config")
	if err != nil {
		panic(err.Error())
	}

	// 2. 通过kubeconfig配置信息实例化ClientSet 该对象用于管理所有Resource的客户端
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		panic(err.Error())
	}

	// 3. 查询
	result, err := clientset.
		CoreV1().            // 返回CoreV1Client实例
		Pods("kube-system"). // 指定查询的资源预计指定资源的namespace，namespace如果为空，表示查询所有namespace
		// Namespaces().     // 查询namespace
		List(context.Todo(), Metav1.ListOptions{Limit: 50})
	if err != nil {
		panic(err.Error())
	}
	/*
		1) CoreV1返回CoreV1Client实例对象
		2) Pods 调用了newPods函数，该函数返回的试PodInterface对象，PodInterface对象实现了Pods资源相关的全部方法，同时再newPods里面还将RESTClient实例对象赋值给了对应的Client属性
		3) List内部使用RestClient与k8s APIServer进行了交互
	*/

	/*
		1) clientset.CoreV1().Pods表示请求core核心资源组的v1资源版本下的Pod资源对象，其内部设置了APIPath请求的HTTP路径，GroupVersion请求的资源组、资源版本，NegotiatedSerializer数据的编解码器。
		2) Pods函数是一个资源对象接口，用于Pod资源对象的管理。例如，对Pod资源执行Create、Update、Delete、Get、List、Watch、Patch等操作，这些操作实际上是对RESTClient进行了封装，可以设置选项（如Limit、TimeoutSeconds等）。
	*/

	// 4. 格式化输出结果
	for _, item := range result.Items {
		fmt.Printf("namespace: %v, name: %v, status: %v\n", item.Namespace, item.Name, item.Status.Phase)
	}

}

Dynamicclient

Dynamicclient是一种动态客户端，它可以对任意Kubernetes资源进行RESTFul操作，包括CRD自定义资源。

Dynamicclient与ClientSet操作类似，同样封装了RESTClient，同样提供了Create、Update、Delete、Get、List、Watch、Patch等方法。

Dynamicclient与ClientSet最大的不同之处在于：

• ClientSet仅能访问Kubernetes自带的资源（即客户端几核内的资源），不能直接访问CRD自定义资源。ClientSet需要预先实现每种Resource和Version的操作，其内部的数据都是结构化数据（即已知数据结构）

• Dynamicclient内部实现了Unstructured，用于处理非结构化数据结构（即无法提前预知数据结构），这也是Dynamicclient能够处理CRD自定义资源的关键。

Dynamicclient的处理过程将Resource（例如PodList）转化成Unstructured结构类型，Kubernetes的所有Resource都可以转化为该结构类型。处理完成后，再将Unstructured转换成PodList。整个过程类似于Go语言的interface{}断言转换过程。另外，Unstructured结构类型是通过map[string]interface{}转换的。

两个重要的知识点：

• Object.runtime：Kubernetes中的所有资源对象都实现了这个接口，其中包含DeepcopyObject和GetobjectKind的方法，分别用于对象深拷贝和获取对象的具体资源类型。
• Unstructured：包含map[string]interface{}类型字段，在处理无法预知结构的数据时，将数据值存入interface{}中，待运行时利用反射判断。该结构体提供了大量的工具方法，便于处理非结构化的数据。

demo示例：通过Dynamicclient示例列出某一命名空间下的Pod资源对象

package main

import (
	"context"
	"fmt"

	corev1 "k8s.io/api/core/v1"
	Metav1 "k8s.io/apimachinery/pkg/apis/Meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/client-go/dynamic"
	"k8s.io/client-go/tools/clientcmd"
)

/*
	@Author: ningan
	@Desc: 获取kube-system命名空间下的Pod列表
*/

func main() {
	// 1. 加载配置文件，生成config对象
	config, err := clientcmd.BuildConfigFromFlags("", "/root/.kube/config")
	if err != nil {
		panic(err.Error())
	}

	// 2. 通过kubeconfig配置信息实例化客户端对象，这里是实例化动态客户端对象。该对象用于管理Kubernetes的所有Resource的客户端，例如对Resource执行Create、Update、Delete、Get、List、Watch、Patch等操作。
	dynamicclient, err := dynamic.NewForConfig(config)
	if err != nil {
		panic(err.Error())
	}

	// 3. 配置需要调用的GVR
	gvr := schema.GroupVersionResource{
		Group:    "",
		Version:  "v1",
		Resource: "pods",
	}

	// 4. 发送请求，并得到返回结果
	unstructedobj, err := dynamicclient.
		Resource(gvr).
		Namespace("kube-system").
		List(context.Todo(), Metav1.ListOptions{})
	if err != nil {
		panic(err.Error())
	}

	// 5. unstructedobj转化为结构化数据
	podList := &corev1.PodList{}
	err = runtime.DefaultUnstructuredConverter.FromUnstructured(
		unstructedobj.UnstructuredContent(),
		podList,
	)
	if err != nil {
		panic(err.Error())
	}
	/*
		1) Resource：基于gvr生成了一个针对于资源的客户端，也可以称之为动态资源客户端，dunamicResourceClient
		2) Namespace：指定一个可操作的命名空间，同时它是dynamicResourceClient的方法
		3) List：首先通过RESTClient调用k8s APIServer的接口返回了Pod的数据，返回的数据格式是二进制的Json格式，然后通过一些列的解析方法，转换成unstructured.UnstructuredList
	*/

	/*
		1) dynamicclient.Resource()函数用于设置请求的资源组、资源版本、资源名称。
		2) Namespace函数用于设置请求的命名空间。
		3) List函数用户获取Pod列表，得到的Pod列表为unstructured.UnstructuredList指针类型
		4) 然后通过runtime.DefaultUnstructuredConverter.FromUnstructured函数将unstructured.UnstructuredList转换为PodList类型。
	*/

	// 6. 格式化输出结果
	for _, item := range podList.Items {
		fmt.Printf("namespace: %v, name: %v, status: %v\n", item.Namespace, item.Name, item.Status.Phase)
	}
}

discoveryClient

discoveryClient是发现客户端，它主要用于发现Kubernetes API Server所支持的资源组、资源版本、资源信息。

Kubernetes API Server支持很多资源组、资源版本、资源信息，开发者可以通过discoveryClient进行查看。

kuectlde api-versions和api-resources命令输出也是通过discoveryClient实现的。另外，discoveryClient也是子啊RESTClient的基础上进行了封装。

discoveryClient除了可以发现Kubernetes API Server所支持的资源组、资源版本、资源信息，还可以将这些信息存储到本地，用于本地缓存（cache），以减轻对Kubernetes API Server访问的压力。在运行Kubernetes组件的机器上，缓存信息默认存储与_{/.kube/cache和}/.kube/http-cache下。

demo示例：通过Dynamicclient列出Kubernetes API Server所支持的资源组、资源版本、资源信息

package main

import (
	"fmt"

	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/client-go/discovery"
	"k8s.io/client-go/tools/clientcmd"
)

/*
	@Author: ningan
	@Desc: 通过Dynamicclient列出Kubernetes API Server所支持的资源组、资源版本、资源信息
*/

func main() {
	// 1. 加载配置文件，生成config对象
	config, err := clientcmd.BuildConfigFromFlags("", "/root/.kube/config")
	if err != nil {
		panic(err.Error())
	}

	// 2. 通过kubeconfig配置信息实例化discoveryClient对象，这个对象是用于发现Kubernetes API Server所支持的资源组、资源版本、资源信息的客户端。
	discoveryClient, err := discovery.NewdiscoveryClientForConfig(config)
	if err != nil {
		panic(err.Error())
	}

	// 3. 发送请求，获取GVR数据
	_, apiResourcesList, err := discoveryClient.ServerGroupsAndResources()
	if err != nil {
		panic(err.Error())
	}
	/*
		1) ServerGroups负责获取gv数据
		2) 然后调用fetchGroupVersionResources，且给这个方法传递gv参数，通过调用ServerResourcesForGroupVersion方法获取gv对应的Resource数据，同时返回一个map[gv]resourceList的数据格式
		3) 处理map->slice，然后返回GCR slice
	*/

	/*
		Kubernetes API Server暴露出/api和/apis接口。discoveryClient通过RESTClient分别请求/api和/apis接口，从而获取Kubernetes API Server所支持的资源组、资源版本、资源信息。核心实现位于：ServerGroupsAndResources->ServerGroups中

	*/

	for _, list := range apiResourcesList {
		gv, err := schema.ParseGroupVersion(list.GroupVersion)
		if err != nil {
			panic(err.Error())
		}

		for _, resource := range list.APIResources {
			fmt.Printf("name: %v, group: %v, version: %v\n", resource.Name, gv.Group, gv.Version)
		}
	}

}

[root@master demo1]# go run main.go
name: bindings, group: , version: v1
name: componentstatuses, group: , version: v1
name: configmaps, group: , version: v1
name: endpoints, group: , version: v1
name: events, group: , version: v1
name: limitranges, group: , version: v1
name: namespaces, group: , version: v1
name: namespaces/finalize, group: , version: v1
name: namespaces/status, group: , version: v1
name: nodes, group: , version: v1
name: nodes/proxy, group: , version: v1
name: nodes/status, group: , version: v1
name: persistentvolumeclaims, group: , version: v1
name: persistentvolumeclaims/status, group: , version: v1
name: persistentvolumes, group: , version: v1
name: persistentvolumes/status, group: , version: v1
name: pods, group: , version: v1
name: pods/attach, group: , version: v1
name: pods/binding, group: , version: v1
name: pods/eviction, group: , version: v1
name: pods/exec, group: , version: v1
name: pods/log, group: , version: v1
name: pods/portforward, group: , version: v1
name: pods/proxy, group: , version: v1
name: pods/status, group: , version: v1
name: podtemplates, group: , version: v1
name: replicationcontrollers, group: , version: v1
name: replicationcontrollers/scale, group: , version: v1
name: replicationcontrollers/status, group: , version: v1
name: resourcequotas, group: , version: v1
name: resourcequotas/status, group: , version: v1
name: secrets, group: , version: v1
name: serviceaccounts, group: , version: v1
name: services, group: , version: v1
name: services/proxy, group: , version: v1
name: services/status, group: , version: v1
name: apiservices, group: apiregistration.k8s.io, version: v1
name: apiservices/status, group: apiregistration.k8s.io, version: v1
name: apiservices, group: apiregistration.k8s.io, version: v1beta1
name: apiservices/status, group: apiregistration.k8s.io, version: v1beta1
name: ingresses, group: extensions, version: v1beta1
name: ingresses/status, group: extensions, version: v1beta1
name: controllerrevisions, group: apps, version: v1
name: daemonsets, group: apps, version: v1
name: daemonsets/status, group: apps, version: v1
name: deployments, group: apps, version: v1
name: deployments/scale, group: apps, version: v1
name: deployments/status, group: apps, version: v1
name: replicasets, group: apps, version: v1
name: replicasets/scale, group: apps, version: v1
name: replicasets/status, group: apps, version: v1
name: statefulsets, group: apps, version: v1
name: statefulsets/scale, group: apps, version: v1
name: statefulsets/status, group: apps, version: v1
name: events, group: events.k8s.io, version: v1
name: events, group: events.k8s.io, version: v1beta1
name: tokenreviews, group: authentication.k8s.io, version: v1
name: tokenreviews, group: authentication.k8s.io, version: v1beta1
name: localsubjectaccessreviews, group: authorization.k8s.io, version: v1
name: selfsubjectaccessreviews, group: authorization.k8s.io, version: v1
name: selfsubjectrulesreviews, group: authorization.k8s.io, version: v1
name: subjectaccessreviews, group: authorization.k8s.io, version: v1
name: localsubjectaccessreviews, group: authorization.k8s.io, version: v1beta1
name: selfsubjectaccessreviews, group: authorization.k8s.io, version: v1beta1
name: selfsubjectrulesreviews, group: authorization.k8s.io, version: v1beta1
name: subjectaccessreviews, group: authorization.k8s.io, version: v1beta1
name: horizontalpodautoscalers, group: autoscaling, version: v1
name: horizontalpodautoscalers/status, group: autoscaling, version: v1
name: horizontalpodautoscalers, group: autoscaling, version: v2beta1
name: horizontalpodautoscalers/status, group: autoscaling, version: v2beta1
name: horizontalpodautoscalers, group: autoscaling, version: v2beta2
name: horizontalpodautoscalers/status, group: autoscaling, version: v2beta2
name: jobs, group: batch, version: v1
name: jobs/status, group: batch, version: v1
name: cronjobs, group: batch, version: v1beta1
name: cronjobs/status, group: batch, version: v1beta1
name: certificatesigningrequests, group: certificates.k8s.io, version: v1
name: certificatesigningrequests/approval, group: certificates.k8s.io, version: v1
name: certificatesigningrequests/status, group: certificates.k8s.io, version: v1
name: certificatesigningrequests, group: certificates.k8s.io, version: v1beta1
name: certificatesigningrequests/approval, group: certificates.k8s.io, version: v1beta1
name: certificatesigningrequests/status, group: certificates.k8s.io, version: v1beta1
name: ingressclasses, group: networking.k8s.io, version: v1
name: ingresses, group: networking.k8s.io, version: v1
name: ingresses/status, group: networking.k8s.io, version: v1
name: networkpolicies, group: networking.k8s.io, version: v1
name: ingressclasses, group: networking.k8s.io, version: v1beta1
name: ingresses, group: networking.k8s.io, version: v1beta1
name: ingresses/status, group: networking.k8s.io, version: v1beta1
name: poddisruptionbudgets, group: policy, version: v1beta1
name: poddisruptionbudgets/status, group: policy, version: v1beta1
name: podsecuritypolicies, group: policy, version: v1beta1
name: clusterrolebindings, group: rbac.authorization.k8s.io, version: v1
name: clusterroles, group: rbac.authorization.k8s.io, version: v1
name: rolebindings, group: rbac.authorization.k8s.io, version: v1
name: roles, group: rbac.authorization.k8s.io, version: v1
name: clusterrolebindings, group: rbac.authorization.k8s.io, version: v1beta1
name: clusterroles, group: rbac.authorization.k8s.io, version: v1beta1
name: rolebindings, group: rbac.authorization.k8s.io, version: v1beta1
name: roles, group: rbac.authorization.k8s.io, version: v1beta1
name: csidrivers, group: storage.k8s.io, version: v1
name: csinodes, group: storage.k8s.io, version: v1
name: storageclasses, group: storage.k8s.io, version: v1
name: volumeattachments, group: storage.k8s.io, version: v1
name: volumeattachments/status, group: storage.k8s.io, version: v1
name: csidrivers, group: storage.k8s.io, version: v1beta1
name: csinodes, group: storage.k8s.io, version: v1beta1
name: storageclasses, group: storage.k8s.io, version: v1beta1
name: volumeattachments, group: storage.k8s.io, version: v1beta1
name: mutatingwebhookconfigurations, group: admissionregistration.k8s.io, version: v1
name: validatingwebhookconfigurations, group: admissionregistration.k8s.io, version: v1
name: mutatingwebhookconfigurations, group: admissionregistration.k8s.io, version: v1beta1
name: validatingwebhookconfigurations, group: admissionregistration.k8s.io, version: v1beta1
name: customresourcedeFinitions, group: apiextensions.k8s.io, version: v1
name: customresourcedeFinitions/status, group: apiextensions.k8s.io, version: v1
name: customresourcedeFinitions, group: apiextensions.k8s.io, version: v1beta1
name: customresourcedeFinitions/status, group: apiextensions.k8s.io, version: v1beta1
name: priorityclasses, group: scheduling.k8s.io, version: v1
name: priorityclasses, group: scheduling.k8s.io, version: v1beta1
name: leases, group: coordination.k8s.io, version: v1
name: leases, group: coordination.k8s.io, version: v1beta1
name: runtimeclasses, group: node.k8s.io, version: v1beta1
name: endpointslices, group: discovery.k8s.io, version: v1beta1
name: cukclusters, group: dubhe.welkin, version: v1alpha1
name: cukclusters/status, group: dubhe.welkin, version: v1alpha1
name: cuknodes, group: dubhe.welkin, version: v1alpha1
name: cuknodes/status, group: dubhe.welkin, version: v1alpha1
name: cuksets, group: dubhe.welkin, version: v1alpha1
name: cuksets/status, group: dubhe.welkin, version: v1alpha1
name: nodes, group: metrics.k8s.io, version: v1beta1
name: pods, group: metrics.k8s.io, version: v1beta1

将GVR缓存到本地

可以发现，GVR数据其实是很少变动的，因此我们可以将GVR的数据缓存到本地，来减少Client与Apiserver交互。

在discovery/cached中，有另外两个客户端是来实现将GVR数据缓存到本地文件中和内存中的，分别是CacheddiscoveryClient和memCacheClient。

平时管理集群的kubectl命令也是使用这种方式来使用GVR与APIServer交互的。

discoveryClient除了可以发现Kubernetes API Server所支持的资源组、资源版本、资源信息，还可以将这些信息存储到本地，用于本地缓存（cache），以减轻对Kubernetes API Server访问的压力。在运行Kubernetes组件的机器上，缓存信息默认存储与_{/.kube/cache和}/.kube/http-cache下。

package main

import (
	"fmt"
	"time"

	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/client-go/discovery/cached/disk"
	"k8s.io/client-go/tools/clientcmd"
)

/*
	@Author: ningan
	@Desc: 将GVR数据缓存到本地
*/

func main() {
	// 1. 加载配置文件，生成config对象
	config, err := clientcmd.BuildConfigFromFlags("", "/root/.kube/config")
	if err != nil {
		panic(err.Error())
	}

	// 2. 实例化客户端，本客户端负责将GVR数据缓存到本地文件中
	cacheddiscoveryClient, err := disk.NewCacheddiscoveryClientForConfig(config, "./cache/discovery", "./cache/http", time.Minute*60)
	if err != nil {
		panic(err.Error())
	}

	_, apiResourcesList, err := cacheddiscoveryClient.ServerGroupsAndResources()
	if err != nil {
		panic(err.Error())
	}

	/*
		1) 先从缓存文件中找GVR数据，有则直接返回，没有则调用APIServer
		2) 嗲用APIServer获取GVR数据
		3) 将获取到的GVR数据缓存到本地，然后返回给客户端

	*/

	for _, list := range apiResourcesList {
		gv, err := schema.ParseGroupVersion(list.GroupVersion)
		if err != nil {
			panic(err.Error())
		}

		for _, resource := range list.APIResources {
			fmt.Printf("name: %v, group: %v, version: %v\n", resource.Name, gv.Group, gv.Version)
		}
	}
}

执行go run main.go之后，确实生成了cache目录

[root@master demo2]# tree -L 2
.
├── cache
│   ├── discovery
│   └── http
└── main.go

3 directories, 1 file

参考

Kubernetes源码剖析 5.2节 Client客户端对象

b站视频：Client-go实战教程

.net学习笔记之 AJAX学习

.NET开发人员关于ML.NET的入门学习

ML.NET一直在微软的研究部门的工作。这些创新已经用于他们自己的产品，如Windows Defender，Microsoft Office（Powerpoint设计理念，Excel图表推荐），Azure机器学习，PowerBI。 ML.NET旨在提供终端工作流程，以便在机器学习（预处理，特征工程，建模，评估和操作）的各个步骤中将ML用于.NET应用程序。

ML.NET 1.0提供以下关键组件：数据表示机器学习任务（分类，回归，异常检测等）数据特征工程

机器学习模型应该让分析师的生活更轻松，现在甚至可以构建这些模型，因为新框架的设计考虑了AutoML。除了通常的机器学习任务外，ML.NET还支持AutoML。

对于机器学习初学者，Microsoft开发人员建议从Visual Studio中的ML.NET模型构建器和任何平台上的ML.NET CLI开始。对于可以随时构建模型的场景，AutoML API也非常方便。

使用ML.NET模型构建器，只需右键单击即可向应用程序添加机器学习。

在命令行使用ML.NET

还引入了另一个工具ML.NET CLI（命令行工具），它允许使用AutoML和ML.NET生成ML.NET模型。ML.NET CLI快速遍历特定ML任务的数据集（目前支持回归和分类）并生成最佳模型。

CLI除了生成最佳模型外，还允许用户为最佳性能模型生成模型训练和 消费模型代码。

ML.NET CLI是跨平台的，是.NET CLI 的全局工具。Visual Studio扩展ML.NET Model Builder 还使用ML.NET CLI提供模型构建器功能。

安装ML.NET CLI：

dotnet tool install -g mlnet 

这是使用回归预测出租车票价的代码

加载数据集

IDataView trainingDataView = mlContext.Data.LoadFromTextFile(TrainDataPath, hasHeader: true); 

IDataView testDataView = mlContext.Data.LoadFromTextFile(TestDataPath, hasHeader: true); 

运行AutoML二进制分类

ExperimentResult experimentResult = mlContext.Auto().CreateRegressionExperiment(ExperimentTime).Execute(trainingDataView, LabelColumnName, progressHandler: new RegressionExperimentProgressHandler());

模型评估

ITransformer model = experimentResult.BestRun.Model; 

并使用测试数据集评估其质量（taxi-fare-test.csv）。

Regression.Evaluate() 计算已知票价与模型预测值之间的差异，以生成各种指标。

var predictions = trainedModel.Transform(testDataView); 
var metrics = mlContext.Regression.Evaluate（predictions，scoreColumnName：“Score”）;

创建预测引擎

var predEngine = mlContext.Model.CreatePredictionEngine<TaxiTrip, TaxiTripFarePrediction>(model);

计算分数

var predictedResult = predEngine.Predict(taxiTripSample); 

上面是使用Visual Studio内部的模型构建器以及CLI命令测试AutoML，还有一个API可以在.Net应用程序中使用它，使用非常简单，添加[ Microsoft.ML.AutoML ] nuget包到项目中就可以使用API 进行工作

ML.Net示例仓库中有一整套示例。可以重用了Common文件夹中的一些类来通过API使用AutoML 。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

Android多媒体学习

一、Image的获取可以通过调Android自带的Camera应用来完成。该应用含有一个Intent-Filter。通过使用
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE)；startActivityForResult(intent)就可以启动Camera应用了。
二、Image存储，Android系统中含有一个多媒体库，其中包括所有Image、Video、Audio的数据。通过MediaStore对象可以访问相关数据。
闲话少说，直接看例子，这是一本英文书上的，觉得写的很好，自己翻译了一下，并加入了很多注释。以备查询。

 package demo.camera;  
import java.io.File;  
import android.app.Activity;  
import android.content.ContentValues;  
import android.content.Intent;  
import android.graphics.Bitmap;  
import android.graphics.BitmapFactory;  
import android.net.Uri;  
import android.os.Bundle;  
import android.os.Environment;  
import android.provider.MediaStore;  
import android.util.Log;  
import android.view.Display;  
import android.view.View;  
import android.widget.Button;  
import android.widget.ImageView;  
/** 
 * 这里多媒体第一个示例，主要介绍Image的获取和存储 
 * Image的获取可以通过Android自带的Camera应用来获得， 
 * 图片的存储需要用到MediaStore对象。Android中的多媒体库。 
 *  
 * @author Administrator 
 * 
 */  
public class MainActivity extends Activity {  
      
    private static final int RESULT_CODE = 1;  
    private Button btnCamera;  
    private ImageView imageView;  
      
    private Uri imageFilePath;  
      
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
          
          
        imageView = (ImageView)this.findViewById(R.id.imageView);  
        btnCamera = (Button)this.findViewById(R.id.camera);  
        btnCamera.setOnClickListener(new View.OnClickListener() {  
              
            @Override  
            public void onClick(View v) {  
                  
                  
                /** 
                 * 由于Camara返回的是缩略图，我们可以传递给他一个参数EXTRA_OUTPUT, 
                 * 来将用Camera获取到的图片存储在一个指定的URI位置处。 
                 * 下面就指定image存储在SDCard上，并且文件名为123.jpg 
                 * imageFilePath = Environment.getExternalStorageDirectory().getAbsolutePath()+"123.jpg"; 
                 * File file = new File(imageFilePath); //创建一个文件 
                 * Uri imageUri = Uri.fromFile(file); 
                 * 然而Android已经提供了一个多媒体库，那里统一存放了设备上所有的多媒体数据。所以， 
                 * 我们可以将获取到的图片存放在那个多媒体库中。 
                 * Android提供了MediaStore类，该类是一个ContentProvider，管理着设备上自带的和外部的多媒体文件， 
                 * 同时包含着每一个多媒体文件的数据信息。 
                 * 为了将数据存储在多媒体库，使用ContentResolver对象来操纵MediaStore对象 
                 * 在MediaStore.Images.Media中有两个URI常量，一个是    EXTERNAL_CONTENT_URI,另一个是INTERNAL_CONTENT_URI 
                 * 第一个URI对应着外部设备(SDCard)，第二个URI对应着系统设备内部存储位置。 
                 * 对于多媒体文件，一般比较大，我们选择外部存储方式 
                 * 通过使用ContentResolver对象的insert方法我们可以向MediaStore中插入一条数据 
                 * 这样在检索那张图片的时候，不再使用文件的路径，而是根据insert数据时返回的URI，获取一个InputStream 
                 * 并传给BitmapFactory 
                 */  
                //在这里启动Camera。 
  
                //Camera中定义了一个Intent-Filter，其中Action是android.media.action.IMAGE_CAPTURE 
  
                //我们使用的时候，最好不要直接使用这个，而是用MediaStore中的常量ACTION_IMAGE_CAPTURE. 
  
                //这个常量就是对应的上面的action   
                Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);  
              
                //这里我们插入一条数据，ContentValues是我们希望这条记录被创建时包含的数据信息 
  
                //这些数据的名称已经作为常量在MediaStore.Images.Media中,有的存储在MediaStore.MediaColumn中了 
  
                //ContentValues values = new ContentValues(); 
  
                ContentValues values = new ContentValues(3);  
                values.put(MediaStore.Images.Media.DISPLAY_NAME, "testing");  
                values.put(MediaStore.Images.Media.DESCRIPTION, "this is description");  
                values.put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg");  
                imageFilePath = MainActivity.this.getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);  
                intent.putExtra(MediaStore.EXTRA_OUTPUT, imageFilePath); //这样就将文件的存储方式和uri指定到了Camera应用中   
                  
                //由于我们需要调用完Camera后，可以返回Camera获取到的图片， 
  
                //所以，我们使用startActivityForResult来启动Camera                     
  
                startActivityForResult(intent, RESULT_CODE);  
                  
            }  
        });  
    }  
    /** 
     * 为了获取Camera返回的图片信息，重写该方法。 
     */  
    @Override  
    public void onActivityResult(int requestCode, int resultCode, Intent data){  
        super.onActivityResult(requestCode, resultCode, data);  
        if(resultCode == RESULT_CODE){  
            //说明是由Camera返回的数据 
  
            //由Camera应用返回的图片数据是一个Camera对象，存储在一个名为data的extra域 
  
            //然后将获取到的图片存储显示在ImageView中 
  
              
            try {  
                Bundle extra = data.getExtras();  
                /** 
                 * 然而为了节约内存的消耗，这里返回的图片是一个121*162的缩略图。 
                 * 那么如何返回我们需要的大图呢？看上面 
                 * 然而存储了图片。有了图片的存储位置，能不能直接将图片显示出来呢》 
                 * 这个问题就设计到对于图片的处理和显示，是非常消耗内存的，对于PC来说可能不算什么，但是对于手机来说 
                 * 很可能使你的应用因为内存耗尽而死亡。不过还好，Android为我们考虑到了这一点 
                 * Android中可以使用BitmapFactory类和他的一个内部类BitmapFactory.Options来实现图片的处理和显示 
                 * BitmapFactory是一个工具类，里面包含了很多种获取Bitmap的方法。BitmapFactory.Options类中有一个inSampleSize，比如设定他的值为8，则加载到内存中的图片的大小将 
                 * 是原图片的1/8大小。这样就远远降低了内存的消耗。 
                 * BitmapFactory.Options op = new BitmapFactory.Options(); 
                 * op.inSampleSize = 8; 
                 * Bitmap pic = BitmapFactory.decodeFile(imageFilePath, op); 
                 * 这是一种快捷的方式来加载一张大图，因为他不用考虑整个显示屏幕的大小和图片的原始大小 
                 * 然而有时候，我需要根据我们的屏幕来做相应的缩放，如何操作呢？ 
                 *  
                 */  
                //首先取得屏幕对象 
  
                Display display = this.getWindowManager().getDefaultDisplay();  
                //获取屏幕的宽和高 
  
                int dw = display.getWidth();  
                int dh = display.getHeight();  
                /** 
                 * 为了计算缩放的比例，我们需要获取整个图片的尺寸，而不是图片 
                 * BitmapFactory.Options类中有一个布尔型变量inJustDecodeBounds，将其设置为true 
                 * 这样，我们获取到的就是图片的尺寸，而不用加载图片了。 
                 * 当我们设置这个值的时候，我们接着就可以从BitmapFactory.Options的outWidth和outHeight中获取到值 
                 */  
                BitmapFactory.Options op = new BitmapFactory.Options();  
                //op.inSampleSize = 8; 
  
                op.inJustDecodeBounds = true;  
                //Bitmap pic = BitmapFactory.decodeFile(imageFilePath, op);//调用这个方法以后，op中的outWidth和outHeight就有值了 
  
                //由于使用了MediaStore存储，这里根据URI获取输入流的形式 
  
                Bitmap pic = BitmapFactory.decodeStream(this  
                        .getContentResolver().openInputStream(imageFilePath),  
                        null, op);  
                int wRatio = (int) Math.ceil(op.outWidth / (float) dw); //计算宽度比例 
  
                int hRatio = (int) Math.ceil(op.outHeight / (float) dh); //计算高度比例 
  
                Log.v("Width Ratio:", wRatio + "");  
                Log.v("Height Ratio:", hRatio + "");  
                /** 
                 * 接下来，我们就需要判断是否需要缩放以及到底对宽还是高进行缩放。 
                 * 如果高和宽不是全都超出了屏幕，那么无需缩放。 
                 * 如果高和宽都超出了屏幕大小，则如何选择缩放呢》 
                 * 这需要判断wRatio和hRatio的大小 
                 * 大的一个将被缩放，因为缩放大的时，小的应该自动进行同比率缩放。 
                 * 缩放使用的还是inSampleSize变量 
                 */  
                if (wRatio > 1 && hRatio > 1) {  
                    if (wRatio > hRatio) {  
                        op.inSampleSize = wRatio;  
                    } else {  
                        op.inSampleSize = hRatio;  
                    }  
                }  
                op.inJustDecodeBounds = false; //注意这里，一定要设置为false，因为上面我们将其设置为true来获取图片尺寸了 
  
                pic = BitmapFactory.decodeStream(this.getContentResolver()  
                        .openInputStream(imageFilePath), null, op);  
                imageView.setImageBitmap(pic);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }   
        }  
    }  
}

检索并显示媒体库中的图片

如果你在模拟器已经启动的情况下，push了几张图片到SDCard中，建议将模拟器关了，再重新启动一下，否则，刚刚添加的图片，是没有办法获取到的。这是因为Android是在系统启动的时候来扫描模拟器上SDCard中多媒体文件的。

 package demo.camera;  
import android.app.Activity;  
import android.database.Cursor;  
import android.graphics.Bitmap;  
import android.graphics.BitmapFactory;  
import android.os.Bundle;  
import android.provider.MediaStore.Images.Media;  
import android.util.Log;  
import android.view.View;  
import android.widget.ImageButton;  
import android.widget.TextView;  
/** 
 * 该类完成图片的检索，显示功能 
 * @author Administrator 
 * 
 */  
public class PhotoManager extends Activity {  
      
    public static final float DISPLAY_WIDTH = 200;  
    public static final float DISPLAY_HEIGHT = 200;  
      
    //这里采用ImageButton的原因是有Button的作用 
  
    private ImageButton photoView;  
    private TextView nameView;  
      
    private Cursor cursor;  
      
    private String photoPath; //存放某张图片对应的位置信息   
    private Bitmap currPhoto;  
      
    //这三个变量主要用来保存Media.DATA,Media.TITLE,Media.DISPLAY_NAME的索引号，来获取每列的数据 
  
    private int photoIndex;  
    //private int titleIndex; 
  
    private int nameIndex;  
      
    public void onCreate(Bundle savedInstanceState){  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.photo_view);  
          
        photoView = (ImageButton)this.findViewById(R.id.image_view);  
        photoView.setOnClickListener(clickListener);  
        nameView = (TextView)this.findViewById(R.id.view_name);  
          
        //指定获取的列 
  
        String columns[] = new String[]{  
                Media.DATA,Media._ID,Media.TITLE,Media.DISPLAY_NAME  
        };  
        //cursor = this.managedQuery(Media.EXTERNAL_CONTENT_URI, columns, null, null, null); 
  
        cursor = this.getContentResolver().query(Media.EXTERNAL_CONTENT_URI, columns, null, null, null);  
        photoIndex = cursor.getColumnIndexOrThrow(Media.DATA);  
        //titleIndex = cursor.getColumnIndexOrThrow(Media.TITLE); 
  
        nameIndex = cursor.getColumnIndexOrThrow(Media.DISPLAY_NAME);  
          
        Log.v("HERE First:", "First Debug");  
        //显示第一张图片，但是首先要判断一下，Cursor是否有值   
        if(cursor.moveToFirst()){  
            showImage();  
        }  
    }  
      
    private View.OnClickListener clickListener = new View.OnClickListener() {  
          
        @Override  
        public void onClick(View v) {  
              
            if(cursor.moveToNext()){  
                showImage();  
            }  
        }  
    };  
      
    /** 
     * 显示图像信息 
     */  
    private void showImage(){  
        photoPath = cursor.getString(photoIndex); //这里获取到的就是图片存储的位置信息   
        //这里怎样获取图片呢？看decodeBitmap 
  
        Log.v("Photo Path:", photoPath);  
        currPhoto = decodeBitmap(photoPath);  
        photoView.setImageBitmap(currPhoto);  
        nameView.setText(cursor.getString(nameIndex));        
    }  
      
    /** 
     * 从path中获取图片信息 
     * @param path 
     * @return 
     */  
    private Bitmap decodeBitmap(String path){  
        BitmapFactory.Options op = new BitmapFactory.Options();  
        op.inJustDecodeBounds = true;  
        Bitmap bmp = BitmapFactory.decodeFile(path, op); //获取尺寸信息   
        //获取比例大小 
  
        int wRatio = (int)Math.ceil(op.outWidth/DISPLAY_WIDTH);  
        int hRatio = (int)Math.ceil(op.outHeight/DISPLAY_HEIGHT);  
        //如果超出指定大小，则缩小相应的比例 
  
        if(wRatio > 1 && hRatio > 1){  
            if(wRatio > hRatio){  
                op.inSampleSize = wRatio;  
            }else{  
                op.inSampleSize = hRatio;  
            }  
        }  
        op.inJustDecodeBounds = false;  
        bmp = BitmapFactory.decodeFile(path, op);  
        return bmp;  
    }  
      
}

Android自带的Camera应用虽然可以满足大多数情景，但是其灵活性上还有不足。但是Android允许我们定制自己的Camera。

在Android的hardware包中有一个Camera类。这个类就是获取Camera服务的，可以定制Camera等。

可以通过open()方法获取其实例。在使用这个类是需要在AndroidManifest.xml文件中加入相应的权限和特性 

如：  <uses-permission android:name = "android.permission.CAMERA" />
  <uses-feature android:name = "android.hardware.camera" />
  <uses-feature android:name = "android.hardware.camera.autofocus" /> 等。

package demo.camera;  
import java.io.OutputStream;  
import java.util.Iterator;  
import java.util.List;  
import android.app.Activity;  
import android.content.ContentValues;  
import android.content.res.Configuration;  
import android.hardware.Camera;  
import android.net.Uri;  
import android.os.Bundle;  
import android.provider.MediaStore;  
import android.view.SurfaceHolder;  
import android.view.SurfaceView;  
import android.view.View;  
import android.widget.LinearLayout;  
/** 
 * Android自带的Camera应用程序可以完成很多功能。但是当其不能满足我们需要的时候 
 * 我们可以定制自己的Camera。Android提供了Camera类来辅助我们实现自己的Camera。 
 * 这个例子就来定义一个自己的Camera 
 * 首先，在Manifest中需要引入权限<uses-permission android:name="android:permission.CAMERA"/> 
 * 我们需要用来存放取景器的容器，这个容器就是SurfaceView。 
 * 使用SurfaceView的同时，我们还需要使用到SurfaceHolder，SurfaceHolder相当于一个监听器，可以监听 
 * Surface上的变化,通过其内部类CallBack来实现。 
 * 为了可以获取图片，我们需要使用Camera的takePicture方法同时我们需要实现Camera.PictureCallBack类，实现onPictureTaken方法 
 * @author Administrator 
 * 
 */  
public class MyCamera extends Activity implements SurfaceHolder.Callback,Camera.PictureCallback{  
      
    public static final int MAX_WIDTH = 200;  
    public static final int MAX_HEIGHT = 200;  
      
    private SurfaceView surfaceView;  
      
    private Camera camera; //这个是hardare的Camera对象   
      
    public void onCreate(Bundle savedInstanceState){  
        super.onCreate(savedInstanceState);  
        this.setContentView(R.layout.camera);  
        surfaceView = (SurfaceView)this.findViewById(R.id.myCameraView);  
        surfaceView.setFocusable(true);   
        surfaceView.setFocusableInTouchMode(true);  
        surfaceView.setClickable(true);  
        surfaceView.setOnClickListener(new View.OnClickListener() {  
              
            @Override  
            public void onClick(View v) {  
                  
                camera.takePicture(null, null, null, MyCamera.this);  
                  
            }  
        });  
        //SurfaceView中的getHolder方法可以获取到一个SurfaceHolder实例 
  
        SurfaceHolder holder = surfaceView.getHolder();  
        //为了实现照片预览功能，需要将SurfaceHolder的类型设置为PUSH 
  
        //这样，画图缓存就由Camera类来管理，画图缓存是独立于Surface的 
  
        holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);  
        holder.addCallback(this);  
    }  
    @Override  
    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {  
    }  
    @Override  
    public void surfaceCreated(SurfaceHolder holder) {  
        // 当Surface被创建的时候，该方法被调用，可以在这里实例化Camera对象 
  
        //同时可以对Camera进行定制 
  
        camera = Camera.open(); //获取Camera实例   
      
          
        /** 
         * Camera对象中含有一个内部类Camera.Parameters.该类可以对Camera的特性进行定制 
         * 在Parameters中设置完成后，需要调用Camera.setParameters()方法，相应的设置才会生效 
         * 由于不同的设备，Camera的特性是不同的，所以在设置时，需要首先判断设备对应的特性，再加以设置 
         * 比如在调用setEffects之前最好先调用getSupportedColorEffects。如果设备不支持颜色特性，那么该方法将 
         * 返回一个null 
         */  
        try {  
              
            Camera.Parameters param = camera.getParameters();  
            if(this.getResources().getConfiguration().orientation != Configuration.ORIENTATION_LANDSCAPE){  
                //如果是竖屏 
  
                param.set("orientation", "portrait");  
                //在2.2以上可以使用 
  
                //camera.setDisplayOrientation(90); 
  
            }else{  
                param.set("orientation", "landscape");  
                //在2.2以上可以使用 
  
                //camera.setDisplayOrientation(0);               
  
            }  
            //首先获取系统设备支持的所有颜色特效，有复合我们的，则设置；否则不设置 
  
            List<String> colorEffects = param.getSupportedColorEffects();  
            Iterator<String> colorItor = colorEffects.iterator();  
            while(colorItor.hasNext()){  
                String currColor = colorItor.next();  
                if(currColor.equals(Camera.Parameters.EFFECT_SOLARIZE)){  
                    param.setColorEffect(Camera.Parameters.EFFECT_SOLARIZE);  
                    break;  
                }  
            }  
            //设置完成需要再次调用setParameter方法才能生效 
  
            camera.setParameters(param);  
              
            camera.setPreviewDisplay(holder);  
              
            /** 
             * 在显示了预览后，我们有时候希望限制预览的Size 
             * 我们并不是自己指定一个SIze而是指定一个Size，然后 
             * 获取系统支持的SIZE，然后选择一个比指定SIZE小且最接近所指定SIZE的一个 
             * Camera.Size对象就是该SIZE。 
             *  
             */  
            int bestWidth = 0;  
            int bestHeight = 0;  
              
            List<Camera.Size> sizeList = param.getSupportedPreviewSizes();  
            //如果sizeList只有一个我们也没有必要做什么了，因为就他一个别无选择 
  
            if(sizeList.size() > 1){  
                Iterator<Camera.Size> itor = sizeList.iterator();  
                while(itor.hasNext()){  
                    Camera.Size cur = itor.next();  
                    if(cur.width > bestWidth && cur.height>bestHeight && cur.width <MAX_WIDTH && cur.height < MAX_HEIGHT){  
                        bestWidth = cur.width;  
                        bestHeight = cur.height;  
                    }  
                }  
                if(bestWidth != 0 && bestHeight != 0){  
                    param.setPreviewSize(bestWidth, bestHeight);  
                    //这里改变了SIze后，我们还要告诉SurfaceView，否则，Surface将不会改变大小，进入Camera的图像将质量很差 
  
                    surfaceView.setLayoutParams(new LinearLayout.LayoutParams(bestWidth, bestHeight));  
                }  
            }  
            camera.setParameters(param);  
        } catch (Exception e) {  
            // 如果出现异常，则释放Camera对象 
  
            camera.release();  
        }  
          
        //启动预览功能 
  
        camera.startPreview();  
          
    }  
    @Override  
    public void surfaceDestroyed(SurfaceHolder holder) {  
        // 当Surface被销毁的时候，该方法被调用 
  
        //在这里需要释放Camera资源 
  
        camera.stopPreview();  
        camera.release();  
          
    }  
    @Override  
    public void onPictureTaken(byte[] data, Camera camera) {  
        // data是一个原始的JPEG图像数据， 
  
        //在这里我们可以存储图片，很显然可以采用MediaStore   
        //注意保存图片后，再次调用startPreview()回到预览 
  
        Uri imageUri = this.getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, new ContentValues());  
        try {  
            OutputStream os = this.getContentResolver().openOutputStream(imageUri);  
            os.write(data);  
            os.flush();  
            os.close();  
        } catch (Exception e) {  
            // TODO: handle exception 
  
            e.printStackTrace();  
        }  
          
        camera.startPreview();  
    }  
      
      
      
}

图像的编辑和合成

package demo.camera;  
import java.io.FileNotFoundException;  
import android.app.Activity;  
import android.content.Intent;  
import android.graphics.Bitmap;  
import android.graphics.BitmapFactory;  
import android.graphics.Canvas;  
import android.graphics.ColorMatrix;  
import android.graphics.ColorMatrixColorFilter;  
import android.graphics.Matrix;  
import android.graphics.Paint;  
import android.graphics.PorterDuff;  
import android.graphics.PorterDuffXfermode;  
import android.net.Uri;  
import android.os.Bundle;  
import android.provider.MediaStore;  
import android.util.Log;  
import android.view.Menu;  
import android.view.MenuItem;  
import android.view.View;  
import android.widget.Button;  
import android.widget.ImageView;  
/** 
 * 在Android中我们可以对图像进行编辑处理等操作 
 * 包括放大缩小，旋转，偏移，裁剪，以及更改亮度，饱和度等 
 *  
 * 1、首先，从SDCard中选择图片，采用Android自带的Callery应用获得 
 * Gallery是Android自带的图片和视频管理应用 
 * 使用Intent来启动Gallery应用，需要指定两个参数，一个是Action，另一个是多媒体存放的URI 
 * Action是一个通用的Action叫ACTION_PICK，来告诉Gallery，我们想检索数据。 
 * 第二个是Data，是一个URI，这里当然是MediaStore.Images.Media.EXTERNAL_CONTENT_URI 
 * 当在Gallery中选择了一个图片的时候，返回的Intent中的Data域就是所选图片对应的URI 
 *  
 * @author Administrator 
 * 
 */  
public class PhotoProcess extends Activity{  
    public static final int FIRST_PIC = 0;  
    public static final int SECOND_PIC = 1;  
    public static final int MAX_WIDTH = 240;  
    public static final int MAX_HEIGHT = 180;  
    private Button btnSelect,btnSelect2;  
    private ImageView srcImageView, dstImageView;  
      
    private Bitmap srcBitmap, dstBitmap;  
    private Uri imageUri;  
      
      
    public void onCreate(Bundle savedInstanceState){  
        super.onCreate(savedInstanceState);  
        this.setContentView(R.layout.process);  
          
        this.btnSelect = (Button)this.findViewById(R.id.btn_select);  
        btnSelect.setOnClickListener(clickListener);  
        this.btnSelect2 = (Button)this.findViewById(R.id.btn_select2);  
        btnSelect2.setOnClickListener(clickListener2);  
        srcImageView = (ImageView)this.findViewById(R.id.img_src);  
        dstImageView = (ImageView)this.findViewById(R.id.img_dst);  
    }  
      
    private View.OnClickListener clickListener = new View.OnClickListener() {  
          
        @Override  
        public void onClick(View arg0) {  
            // 启动Gallery应用 
  
            Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);  
            startActivityForResult(intent, FIRST_PIC);  
        }  
    };  
    private View.OnClickListener clickListener2 = new View.OnClickListener() {  
          
        @Override  
        public void onClick(View arg0) {  
            // 启动Gallery应用 
  
            Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);  
            startActivityForResult(intent, SECOND_PIC);  
              
        }  
    };    
      
    public boolean onCreateOptionsMenu(Menu menu){  
        //super.onCreateOptionsMenu(menu); 
  
        //MenuInflater menuInflater = new MenuInflater(this); 
  
        //menuInflater.inflate(R.layout.image, menu) 
  
        menu.add(Menu.NONE,1,Menu.NONE,"复制");  
        menu.add(Menu.NONE,2,Menu.NONE,"变换");  
        menu.add(Menu.NONE,3,Menu.NONE,"亮度");  
        menu.add(Menu.NONE,4,Menu.NONE,"合成");  
        return super.onCreateOptionsMenu(menu);  
    }  
      
    public boolean onOptionsItemSelected(MenuItem item){  
        int id = item.getItemId();  
        switch(id){  
        case 1:  
            //复制一个图像 
  
            if(srcBitmap != null){  
                dstBitmap = getDstImage(null);//这里没有变换 
  
                dstImageView.setImageBitmap(dstBitmap);  
            }  
            break;  
        case 2:  
            //对复制后的图像进行变换 
  
            if(srcBitmap != null){  
                dstBitmap = transferImage();  
                dstImageView.setImageBitmap(dstBitmap);  
            }  
            break;  
        case 3:  
            //改变图像的色彩 
  
            if(srcBitmap != null){  
                dstBitmap = ajustImage();  
                dstImageView.setImageBitmap(dstBitmap);  
            }  
            break;  
        case 4:  
            if(srcBitmap != null && dstBitmap != null){  
                dstBitmap = compositeImages();  
                dstImageView.setImageBitmap(dstBitmap);  
            }  
            break;  
        }  
        return true;  
    }  
      
    /** 
     * 为了创建一个图像的副本，我们可以在创建一个新的空的Bitmap，然后在这个Bitmap上绘制一个Bitmap 
     * 这个空的Bitmap应该和已存在的Bitmap具有相同的尺寸和颜色深度 
     *  
     * 然后我们需要一个Canvas对象，一个Canvas简单说，就是一个画布，存放Bitmap，在构造时，就可以传入Bitmap对象 
     * 同时，Canvas中定义了很多便捷的画图方法，方便我们绘制各种图形 
     * 接下来，如果我们需要处理颜色和对比度，我们需要一个Paint对象，通过Paint我们可以设置画笔的各种特性。 
     *  
     * 最后，我们调用Canvas的drawBitmap就可以将原Bitmap绘制在dstBitmap上了 
     *  
     */  
    private Bitmap getDstImage(Matrix matrix){  
          
        Bitmap bmp = null;  
        //下面这个Bitmap中创建的函数就可以创建一个空的Bitmap 
  
        //返回的是一个可以改变的Bitmap对象，这样我们后面就可以对其进行变换和颜色调整等操作了 
  
        bmp = Bitmap.createBitmap(srcBitmap.getWidth(), srcBitmap.getHeight(), srcBitmap.getConfig());  
        //创建Canvas对象， 
  
        Canvas canvas = new Canvas(bmp);   
        //创建Paint对象，这里先不用 
  
        Paint paint = new Paint();  
        //在Canvas上绘制一个已经存在的Bitmap。这样，dstBitmap就和srcBitmap一摸一样了 
  
          
        if(matrix != null){  
            //如果matrix存在，则采用变换 
  
            canvas.drawBitmap(dstBitmap, matrix, paint);  
        }else{  
            canvas.drawBitmap(srcBitmap, 0, 0, paint);  
        }  
          
          
        return bmp;  
  
    }  
      
      
    /** 
     * 重载getDstImage函数，传入定制的Paint对象 
     * @param matrix 
     * @param paint 
     * @return 
     */  
    private Bitmap getDstImage(Matrix matrix, Paint paint){  
          
        Bitmap bmp = null;  
        //下面这个Bitmap中创建的函数就可以创建一个空的Bitmap 
  
        //返回的是一个可以改变的Bitmap对象，这样我们后面就可以对其进行变换和颜色调整等操作了 
  
        bmp = Bitmap.createBitmap(srcBitmap.getWidth(), srcBitmap.getHeight(), srcBitmap.getConfig());  
        //创建Canvas对象， 
  
        Canvas canvas = new Canvas(bmp);   
          
        //在Canvas上绘制一个已经存在的Bitmap。这样，dstBitmap就和srcBitmap一摸一样了 
  
          
        if(matrix != null){  
            //如果matrix存在，则采用变换 
  
            canvas.drawBitmap(dstBitmap, matrix, paint);  
        }else{  
            canvas.drawBitmap(srcBitmap, 0, 0, paint);  
        }  
          
          
        return bmp;  
  
    }     
      
    /** 
     * 为了放大缩小、旋转图像，我们要使用Matrix类。Matrix类是一个三维矩阵。 
     * 在Android屏幕中，图像的每个像素对应都是一个坐标，一个坐标由x/y/z组成 
     * ------------------------ 
     * cosX -sinX translateX 
     * sinX cosX  translateY 
     * 0    0     scale 
     * ------------------------ 
     * 第一行的值，影响着x坐标。比如 1 0 0 =>x = 1*x + 0*y + 0*z 
     * 第二行的值，影响着y坐标。比如0 1 0 => y = 0*x + 1*y + 0*z 
     * 第三行的值，影响着z坐标。比如 0 0 1 => z = 0*x + 0*y + 1*z 
     *  
     * 我们自己计算一个矩阵然后通过Matrax.setValues设置。 
     * 这样，在调用canvas的drawBitmap方法时，传入matrix 
     *  
     * Matrix类并不提倡我们使用这种方式来操作变换，Matrix针对不同的变换都相应的有pre，set，post三种方法 
     * 可以使用。 
     * pre是矩阵前乘 
     * set是直接设置 
     * post是矩阵后乘 
     */  
    private Bitmap transferImage(){  
        Matrix matrix = new Matrix();  
        matrix.setValues(new float[]{  
            .5f,0,0,//这里只会影响到x轴，所以，图片的长度将是原来的一半   
            0,1,0,  
            0,0,1  
        });  
        return this.getDstImage(matrix);  
    }  
      
    /** 
     * 该方法中我们将对图像的颜色，亮度，对比度等进行设置 
     * 需要用到ColorMatrix类。ColorMatrix类是一个四行五列的矩阵 
     * 每一行影响着[R,G,B,A]中的一个 
     * ------------------------- 
     * a1 b1 c1 d1 e1 
     * a2 b2 c2 d2 e2 
     * a3 b3 c3 d3 e3 
     * a4 b4 c4 d4 e4 
     * ------------------------- 
     * Rnew => a1*R+b1*G+c1*B+d1*A+e1 
     * Gnew => a2*R+b2*G+c2*B+d2*A+e2 
     * Bnew => a3*R+b3*G+c3*B+d3*A+e3 
     * Gnew => a4*R+b4*G+c4*B+d4*A+e4 
     * 其中R，G，B的值是128，A的值是0 
     *  
     * 最后将颜色的修改，通过Paint.setColorFilter应用到Paint对象中。 
     * 主要对于ColorMatrix,需要将其包装成ColorMatrixColorFilter对象，再传给Paint对象 
     *  
     * 同样的，ColorMatrix提供给我们相应的方法，setSaturation()就可以设置一个饱和度 
     */  
    private Bitmap ajustImage(){  
        ColorMatrix cMatrix = new ColorMatrix();  
//      int brightIndex = -25; 
  
//      int doubleColor = 2; 
  
//      cMatrix.set(new float[]{ 
  
//              doubleColor,0,0,0,brightIndex, //这里将1改为2则我们让Red的值为原来的两倍 
  
//              0,doubleColor,0,0,brightIndex,//改变最后一列的值，我们可以不改变RGB同道颜色的基础上，改变亮度 
  
//              0,0,doubleColor,0,brightIndex, 
  
//              0,0,0,doubleColor,0 
  
//      }); 
  
        //cMatrix.setSaturation(2.0f);//设置饱和度 
  
        cMatrix.setScale(2.0f, 2.0f, 2.0f, 2.0f);//设置颜色同道色彩缩放 
  
        Paint paint = new Paint();  
        paint.setColorFilter(new ColorMatrixColorFilter(cMatrix));  
        return this.getDstImage(null, paint);  
    }  
      
    /** 
     * 图像的合成，可以通过在同一个Canvas中绘制两张图片。 
     * 只是在绘制第二章图片的时候，需要给Paint指定一个变幻模式TransferMode。 
     * 在Android中有一个XFermode所有的变幻模式都是这个类的子类 
     * 我们需要用到它的一个子类PorterDuffXfermode,关于这个类，其中用到PorterDuff类 
     * 这个类很简单，就包含一个Enum是Mode，其中定义了一组规则，这组规则就是如何将 
     * 一张图像和另一种图像进行合成 
     * 关于图像合成有四种模式，LIGHTEN,DRAKEN,MULTIPLY,SCREEN 
     */  
    private Bitmap compositeImages(){  
          
        Bitmap bmp = null;  
        //下面这个Bitmap中创建的函数就可以创建一个空的Bitmap 
  
        bmp = Bitmap.createBitmap(srcBitmap.getWidth(), srcBitmap.getHeight(), srcBitmap.getConfig());  
        Paint paint = new Paint();  
        Canvas canvas = new Canvas(bmp);  
        //首先绘制第一张图片，很简单，就是和方法中getDstImage一样 
  
        canvas.drawBitmap(srcBitmap, 0, 0, paint);        
          
        //在绘制第二张图片的时候，我们需要指定一个Xfermode   
        //这里采用Multiply模式，这个模式是将两张图片的对应的点的像素相乘 
  
        //，再除以255，然后以新的像素来重新绘制显示合成后的图像   
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.MULTIPLY));  
        canvas.drawBitmap(dstBitmap, 0, 0, paint);  
          
        return bmp;  
    }  
    public void onActivityResult(int requestCode, int resultCode, Intent data){  
        super.onActivityResult(requestCode, resultCode, data);  
          
        Log.v("Result OK Value:", resultCode+"");  
        Log.v("RequestCode Value", requestCode+"");  
          
        if(resultCode == RESULT_OK){  
            imageUri = data.getData();    
            if(requestCode == FIRST_PIC){  
                //在Gallery中选中一个图片时，返回来的Intent中的Data就是选择图片的Uri 
  
                srcBitmap = getSrcImage(imageUri);  
                srcImageView.setImageBitmap(srcBitmap);               
            }else if(requestCode == SECOND_PIC){  
                //这里处理用户选择的第二张图片 
  
                  
                dstBitmap = getSrcImage(imageUri);  
                dstImageView.setImageBitmap(dstBitmap);  
            }  
        }  
    }  
      
    /** 
     * 需要加载的图片可能是大图，我们需要对其进行合适的缩小处理 
     * @param imageUri 
     */  
    private Bitmap getSrcImage(Uri imageUri){  
        //Display display = this.getWindowManager().getDefaultDisplay(); 
  
        try {  
            BitmapFactory.Options ops = new BitmapFactory.Options();  
            ops.inJustDecodeBounds = true;  
            Bitmap bmp = BitmapFactory.decodeStream(this.getContentResolver().openInputStream(imageUri),null,ops);  
            int wRatio = (int)Math.ceil(ops.outWidth/(float)MAX_WIDTH);  
            int hRatio = (int)Math.ceil(ops.outHeight/(float)MAX_HEIGHT);  
              
            if(wRatio > 1 && hRatio > 1){  
                if(wRatio > hRatio){  
                    ops.inSampleSize = wRatio;  
                }else{  
                    ops.inSampleSize = hRatio;  
                }  
            }  
              
            ops.inJustDecodeBounds = false;  
            bmp = BitmapFactory.decodeStream(this.getContentResolver().openInputStream(imageUri),null,ops);  
              
            return bmp;  
              
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block 
  
            e.printStackTrace();  
            Log.e(this.getClass().getName(), e.getMessage());  
        }  
          
        return null;  
    }  
}

调用Android自带的播放器播放audio

Android有其自带的播放器，我们可以使用隐式Intent来调用它：通过传入一个Action为ACTION_VIEW同时，指定Data为所要播放的Audio的Uri对象，并指定格式信息，则我们就可以调用播放器来播放该Audio了。

Intent intent = new Intent(Intent.ACTION_VIEW);

intent.setDataAndType(Uri, MimeType);

startActivity(intent);

本文我们需要访问MediaStore，来获取所有Audio信息，我们首先将获取所有的Album，然后当用户点击某个Album时，显示该Album下所有的Audio，然后当用户点击某个Audio时，调用系统自带的播放器播放该Audio。

package demo.camera;  
import java.io.File;  
import org.apache.http.client.utils.URIUtils;  
import android.app.Activity;  
import android.app.ListActivity;  
import android.content.Intent;  
import android.database.Cursor;  
import android.net.Uri;  
import android.os.Bundle;  
import android.os.Environment;  
import android.provider.MediaStore;  
import android.provider.MediaStore.Audio;  
import android.provider.MediaStore.Audio.Albums;  
import android.view.View;  
import android.widget.Button;  
import android.widget.CursorAdapter;  
import android.widget.ListView;  
import android.widget.SimpleCursorAdapter;  
/** 
 * 本示例演示如何利用Android自带的Music来播放程序 
 * 和Camera一样，可以通过Intent来启动它。 
 * 我们需要指定一个ACTION_VIEW的Action 
 * 同时一个Uri来指定我们要播放文件的路径 
 * 最后指定一个MIME类型，指定所要播放的文件类型 
 * 每种文件类型对应的都有一个MIME，他一般是类似于audio/mp3格式 
 * 前部分是一个较大的类型，后面是更具体的类型 
 *  
 * 同样的，对于Audio类型的多媒体，系统存储在MediaStore.Audio中 
 * 包括Media，Album，Genre等信息体 
 *  
 * 本文将以列表的形式列出所有的Album信息，供用户选择 
 * 当用户选择某个Album时，系统将打开这个ALbum下的所有Audio 
 * @author Administrator 
 * 
 */  
public class AudioDemo extends ListActivity {  
      
    private Button btnMusic;  
      
    private boolean isAlbum = true; //true时，说明当前列表的内容是Album，false时，说明是Media 
  
      
    private Cursor cursor; //游标对象，   
      
    public void onCreate(Bundle savedInstanceState){  
        super.onCreate(savedInstanceState);  
        this.setContentView(R.layout.audio);  
        btnMusic = (Button)this.findViewById(R.id.btn_music);  
        btnMusic.setOnClickListener(new View.OnClickListener() {  
              
            @Override  
            public void onClick(View v) {  
                  
//              Intent intent = new Intent(Intent.ACTION_VIEW); 
  
//              //这里我们先从SDCard文件中获取指定文件的URi 
  
//              File sdcard = Environment.getExternalStorageDirectory(); //这个是获取SDCard路径 
  
//              File audioFile = new File(sdcard.getPath()+"/music/tt.mp3"); 
  
//              //然后需要获取该文件的Uri 
  
//              Uri audioUri = Uri.fromFile(audioFile); 
  
//              //然后指定Uri和MIME 
  
//              intent.setDataAndType(audioUri, "audio/mp3"); 
  
//              startActivity(intent); 
  
                  
                //获取Album列表 
  
                getAlbums();  
                isAlbum = true;  
            }  
        });  
          
    }  
      
    public void onListItemClick(ListView l, View v, int position, long id){  
          
        //判断当前是哪个列表 
  
        if(isAlbum){  
            //如果是Album，当用户点击某一个时，获取该Album下的所有media 
  
            //l.getChildAt(position); 
  
            if(cursor.moveToPosition(position)){  
                getMedias(cursor.getInt(cursor.getColumnIndexOrThrow(Albums._ID)));  
                isAlbum = false;  
            }  
        }else{  
            //如果是Media，则当用户点击某一个时，则播放该Media 
  
            //调用系统自带的MediaPlayer来播放   
            if(cursor.moveToPosition(position)){  
                String mediaUri = cursor.getString(cursor.getColumnIndexOrThrow(Audio.Media.DATA));  
                String type = cursor.getString(cursor.getColumnIndexOrThrow(Audio.Media.MIME_TYPE));  
                Uri data = Uri.fromFile(new File(mediaUri));  
                Intent intent = new Intent(Intent.ACTION_VIEW);  
                intent.setDataAndType(data, type);  
                startActivity(intent);  
            }  
        }  
          
        //super.onListItemClick(l, v, position, id); 
  
    }  
      
      
    //获取所有Albums 
  
    public void getAlbums(){  
        String[] columns = new String[]{  
                Albums._ID,  
                Albums.ALBUM  
        };  
        String[] from = new String[]{  
                Albums.ALBUM  
        };  
        int[] to = new int[]{  
                android.R.id.text1  
        };  
        cursor = this.managedQuery(Albums.EXTERNAL_CONTENT_URI, columns, null, null, Albums.DEFAULT_SORT_ORDER);  
        CursorAdapter adapter = new SimpleCursorAdapter(this, android.R.layout.simple_list_item_1, cursor, from, to);  
        this.setListAdapter(adapter);  
        //this.isAlbum = true; 
  
          
    }  
      
    //获取某个Albums下对应的medias 
  
    public void getMedias(int albumId){  
        String[] columns = new String[]{  
                Audio.Media._ID,  
                Audio.Media.DATA,  
                Audio.Media.DISPLAY_NAME,  
                Audio.Media.MIME_TYPE  
        };  
        String selection = Audio.Media.ALBUM_ID + "=?";  
        String[] selectionArgs = new String[]{  
                albumId+""  
        };  
          
        String[] from = new String[]{  
                Audio.Media.DISPLAY_NAME  
        };  
        int[] to = new int[]{  
                android.R.id.text1  
        };  
          
        cursor = this.managedQuery(Audio.Media.EXTERNAL_CONTENT_URI, columns, selection, selectionArgs, Audio.Media.TITLE);  
        CursorAdapter adapter = new SimpleCursorAdapter(this, android.R.layout.simple_list_item_1,cursor,from,to);  
        this.setListAdapter(adapter);  
    }  
}

利用Service实现背景音乐的播放

Activity类

package demo.camera;  
import android.app.Activity;  
import android.content.ComponentName;  
import android.content.Context;  
import android.content.Intent;  
import android.content.ServiceConnection;  
import android.os.Bundle;  
import android.os.IBinder;  
import android.view.View;  
/** 
 * 演示Activity如何利用Service来完成后台Audio的播放功能 
 * 同时如何将Service和Activity进行绑定 
 * @author Administrator 
 * 
 */  
public class BackgroundAudioDemo extends Activity {  
      
    private AudioService audioService;  
      
    //使用ServiceConnection来监听Service状态的变化 
  
    private ServiceConnection conn = new ServiceConnection() {  
          
        @Override  
        public void onServiceDisconnected(ComponentName name) {  
            // TODO Auto-generated method stub 
  
            audioService = null;  
        }  
          
        @Override  
        public void onServiceConnected(ComponentName name, IBinder binder) {  
            //这里我们实例化audioService,通过binder来实现 
  
            audioService = ((AudioService.AudioBinder)binder).getService();  
              
        }  
    };  
      
    public void onCreate(Bundle savedInstanceState){  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.back_audio);  
    }  
      
      
    public void onClick(View v){  
        int id = v.getId();  
        Intent intent = new Intent();  
        intent.setClass(this, AudioService.class);        
        if(id == R.id.btn_start){  
            //启动Service，然后绑定该Service，这样我们可以在同时销毁该Activity，看看歌曲是否还在播放 
  
            startService(intent);  
            bindService(intent, conn, Context.BIND_AUTO_CREATE);  
            finish();  
        }else if(id == R.id.btn_end){  
            //结束Service 
  
            unbindService(conn);  
            stopService(intent);  
            finish();  
        }else if(id == R.id.btn_fun){  
            audioService.haveFun();  
        }  
    }  
}

Service类

 package demo.camera;  
import android.app.Service;  
import android.content.Intent;  
import android.media.MediaPlayer;  
import android.os.Binder;  
import android.os.IBinder;  
import android.widget.MediaController.MediaPlayerControl;  
/** 
 * 为了可以使得在后台播放音乐，我们需要Service 
 * Service就是用来在后台完成一些不需要和用户交互的动作 
 * @author Administrator 
 * 
 */  
public class AudioService extends Service implements MediaPlayer.OnCompletionListener{  
      
    MediaPlayer player;  
      
    private final IBinder binder = new AudioBinder();  
    @Override  
    public IBinder onBind(Intent arg0) {  
        // TODO Auto-generated method stub 
  
        return binder;  
    }  
    /** 
     * 当Audio播放完的时候触发该动作 
     */  
    @Override  
    public void onCompletion(MediaPlayer player) {  
        // TODO Auto-generated method stub 
  
        stopSelf();//结束了，则结束Service 
  
    }  
      
    //在这里我们需要实例化MediaPlayer对象 
  
    public void onCreate(){  
        super.onCreate();  
        //我们从raw文件夹中获取一个应用自带的mp3文件 
  
        player = MediaPlayer.create(this, R.raw.tt);  
        player.setOnCompletionListener(this);  
    }  
      
    /** 
     * 该方法在SDK2.0才开始有的，替代原来的onStart方法 
     */  
    public int onStartCommand(Intent intent, int flags, int startId){  
        if(!player.isPlaying()){  
            player.start();  
        }  
        return START_STICKY;  
    }  
      
    public void onDestroy(){  
        //super.onDestroy(); 
  
        if(player.isPlaying()){  
            player.stop();  
        }  
        player.release();  
    }  
      
    //为了和Activity交互，我们需要定义一个Binder对象 
  
    class AudioBinder extends Binder{  
          
        //返回Service对象 
  
        AudioService getService(){  
            return AudioService.this;  
        }  
    }  
      
    //后退播放进度 
  
    public void haveFun(){  
        if(player.isPlaying() && player.getCurrentPosition()>2500){  
            player.seekTo(player.getCurrentPosition()-2500);  
        }  
    }  
}

在清单文件AndroidManifest.xml中配置Service

<service
            android:name=".AudioService" />

我们今天的关于电脑入门学习-多媒体学习-internet学习01和多媒体教学电脑的分享已经告一段落，感谢您的关注，如果您想了解更多关于(已导出)【kubernetes系列学习】client-go学习与实践、.net学习笔记之 AJAX学习、.NET开发人员关于ML.NET的入门学习、Android多媒体学习的相关信息，请在本站查询。

最近很多小伙伴都在问电脑入门学习办公学习WORD使用－精彩的表格和办公软件word表格入门教学视频这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展Android Framework 入门学习、Android入门学习_Hello Word程序设计、Aspose.Words for .NET使用表格教程之创建表格——Microsoft Word和Aspose.Words表格介绍、excel表格如何转换为word中的表格等相关知识，下面开始了哦！

• 电脑入门学习办公学习WORD使用－精彩的表格（办公软件word表格入门教学视频）
• Android Framework 入门学习
• Android入门学习_Hello Word程序设计
• Aspose.Words for .NET使用表格教程之创建表格——Microsoft Word和Aspose.Words表格介绍
• excel表格如何转换为word中的表格

电脑入门学习办公学习WORD使用－精彩的表格（办公软件word表格入门教学视频）

电脑技术网教你学电脑入门学习系列视频教程适合刚学电脑的朋友，讲的很简单易懂。对刚学电脑的朋友是比较有帮助的，能快速引导你学习电脑入门。看完这一系列教程，基本上对电脑操作知识有了大概的了解，让你知道可以从哪里入手操作电脑。已经有一定电脑知识的朋友可以跳过此教程。

Android Framework 入门学习

前言

众所皆知，Android系统是当前占据用户量最大的手机系统，国内流行的客户端开发无非是android 与 ios，即使作为一个普通用户，小伙伴们可曾想过这个给我们生活带来巨大变化的系统是如何为我们服务的呢？

Android系统可大致分为五层，如下图，第一层就是我们平时看到的各种应用了，这个小伙伴们肯定熟悉，这里就不多说了，要给大家介绍的是第二层——Framework，它直接对接应用程序，提供了本地系统服务和java系统服务。

那么这些服务是如何使用的呢，下面简要分析一下这个过程

Android Framework

先来看一个应用的启动过程

如上图，一个应用启动主要依赖于ActivityManager服务，它是系统提供的众多服务里的其中一个，服务作为framework提供的主要内容，扮演着承上启下的重要责任：一方面为应用提供约定好的功能调用接口，另一方面无需应用关心服务如何实现，framework会负责与底下驱动层进行交互，达到目的。

正因为有了framework层，应用开发才能事半功倍，专注于业务逻辑实现，接下来就来介绍一下服务如何运行.

1、服务检索

服务检索是指调用服务的客户端向Context Manager(service manager中第一个注册的节点）请求指定服务的handle的过程。调用服务的客户端把包含服务请求信息的IPC数据发送给Context Manager，然后Context Manager通过IPC应答数据将指定服务的handle发送给它。Binder Driver将把调用服务的客户端请求的服务的binder_node结构体注册到客户端的bind_proc结构体中。 

针对上面这段话有三点需要解释一下：

1）service_manager如何查找指定服务的handle，如下代码：

struct svcinfo  

上面就是service_manager.c中的检索服务代码，可以看出service_manager维护一张服务表svclist，可以根据服务名查找对应的结构体svcinfo，这个结构体里面就包含了需要的handle变量，handle值会被保存在BpBinder里面的mHandle变量里面。

2）binder_node是什么？下面是一段服务注册过程中的代码：

fp = (struct flat_binder_object *)(t->buffer->data + *offp);

来看一下bind_ref结构体：

struct binder_ref {

所以binder_node就是服务注册时传入的服务对象，其中第一个参数proc是代表Service Server的binder_proc，因为所有的服务实体都是注册到Service Server，而后面的binder_get_ref_for_node则是将该实体对应的引用注册到Context Manager，即Context Manager拥有所有服务实体对应的引用，Service Server拥有所有服务实体对象，下面是binder_node结构体：

struct binder_node {

其中proc是Service Server进程的binder proc地址，ptr是远程binder对象地址，即BpBinder，cookie是注册的本地服务的binder地址，每次Service Server接收到消息会先把cookie转换成对应的Service对象，然后根据传入的方法编号选择对应的方法执行生成结果数据，这样Service Server只要负责执行就行了，不用管服务对象的查找。

3）什么是binder_proc？首先看一下binder_open函数：

static int binder_open(struct inode *nodp, struct file *filp){

从上面函数可以看出每个进程调用binder_open都会生成自己的binder_proc，从binder_proc结构体可以看出进程间通信主要是靠每个进程在内核空间开辟的一块buffer，通信时一方会把自己的数据传到自己开辟的Buffer里面，然后binder driver负责将这些数据拷贝到目标进程的buffer里，然后唤醒目标进程处理数据就行了。

总结起来服务检索过程有如下几步：

1. Context Manager(ServiceManager)进入待机状态，等待接收IPC数据。
2. 调用服务的客户端生成并初始化binder_proc结构体，而后开辟一块buffer用于接收IPC应答数据
3. 调用服务的客户端通过ioctl()调用binder driver的binder_ioctl()函数。与注册服务时一样，binder driver会查找Context Manager的binder_proc结构体。但与注册服务不同的是，它并不生成binder_node结构体，只是将IPC数据拷贝到Context Manager的接收buffer中。并且记下调用服务客户端的binder_proc结构体，以便查找IPC应答数据的接收端。
4. Binder driver让调用服务的客户端处于待机状态，并唤醒处于待机状态的Context Manager，而后接收IPC数据。从待机状态苏醒的Context Manager在服务目录中查找请求的服务，把服务编号插入到IPC应答数据中，并把IPC应答数据传递给binder driver.
5. Binder dirver将（4）中接收到服务编号去Context Manager中查找相应的binder_node结构体（先查找对应结构体的引用，引用里的一个属性就是binder_node），而后将查找到binder_node结构体注册到调用服务的客户端的binder_proc中。binder_node结构体用于在调用服务时查找Service Server的binder_proc结构体.
6. Binder driver将（5）中注册的binder_node结构体的编号插入到IPC应答数据中，传递给客户端，然后唤醒客户端。在使用服务时，客户端将编号作为handle使用。

2、服务使用

经过服务检索，客户端获得了Service Server所拥有服务的binder_node，在生成IPC数据时，它就可以把要使用服务的binder节点编号设置到IPC数据的handle中，取代原来值为0的handle，服务使用有如下过程：

• Service Server处于待机状态，等待接收IPC数据。
• 客户端将从服务检索中获取的binder节点编号保存到IPC数据的handle(等于binder_ref中的desc）中，生成IPC数据后传递给binder driver，binder driver根据IPC数据中的handle查找相应的binder_ref结构体（ContextManager的binder proc结构体里面保存了所有的binder_ref对象，可以根据desc属性查找对应的binder_ref对象），然后获取binder_ref里面的binder_node对象，而binder_node结构体里面的proc属性就是注册该服务的Service Server的binder_proc地址。最后通过binder_proc结构体中binder_buffer结构体，将IPC数据拷贝到Service Server进程的buffer中。
• Binder driver让客户端进入待机状态，唤醒处于待机状态的Service Server。Service Server从待机状态苏醒后接受IPC数据，并通过IPC数据中的RPC代码、RPC数据调用相应的服务函数。
• 在服务函数执行完毕后，Service Server会生成IPC应答数据，并将其传递给binder driver，binder driver将IPC数据传递给客户端。至此，客户端调用服务的整个IPC过程就完成了。

总结

Android 提供的系统服务我们在开发过程中很多可以通过反射方式调用，不过系统也有提供接口给我们，比如context.getSystemService，不过getSystemService方法获取的是注册在SystemServiceRegistry里面的服务，里面的服务有的是来自系统服务；有的不是，比如Context.WINDOW_SERVICE就不是系统的，而是与当前进程绑定的 WindowManagerImpl(ctx);

参考：https://mp.weixin.qq.com/s/blMeASduNrJqXxH07tmInA

Android百大框架源码解析学习视频

Android入门学习_Hello Word程序设计

       项目就建完了，很简单吧。出乎我的意料。

       现在看看具体代码文件，在左边的package explorer,select project helloworld.

       在src下打开HelloAndriod.java文件。

       android:layout_width
       android:layout_height

       当前VIEW的宽和高。fill_parent的含义在这个程序中是暂居占据整个SCREEN。text 显示的内容，这里采用定义的常量表示。

    res/values/ strings.xml

java代码：

Aspose.Words for .NET使用表格教程之创建表格——Microsoft Word和Aspose.Words表格介绍

Aspose.Words For .Net是一种高级Word文档处理API，用于执行各种文档管理和操作任务。API支持生成，修改，转换，呈现和打印文档，而无需在跨平台应用程序中直接使用Microsoft Word。此外，API支持所有流行的Word处理文件格式，并允许将Word文档导出或转换为固定布局文件格式和最常用的图像/多媒体格式。

【下载Aspose.Words for .NET最新试用版】

接下来我们将进入“使用格式”的介绍，其中包括应用格式、介绍和创建表、添加和拆分表以及使用列和行。

表是word文档中常见的元素。它们允许在具有行和列的网格结构中清晰地组织和显示大量信息。它们还经常用作页面布局工具，并且是显示选项卡数据（带有选项卡停止）的更好选择，因为它们允许更好地控制内容的设计和布局。

表由Cell，Row和Column等元素组成。这些概念通常适用于所有表，无论它们来自Microsoft Word文档还是HTML文档，完全支持Aspose.Words中的表。您可以自由编辑，更改，添加和删除表格。还支持高保真表格的渲染。

Microsoft Word中的表

▲在Microsoft Word中插入表

在Microsoft Word 2003及更早版本中插入表：

1. 单击顶部工具栏中的“表格”菜单。
2. 单击插入，然后单击表格。
3. 填写适当的值，然后按确定以插入表格。

在Microsoft Word 2007及更高版本中插入表：

1. 单击“插入”选项卡。
2. 选择表格下拉菜单。
3. 选择“插入表”。
4. 填写适当的值，然后按确定以插入表格。

▲使用Microsoft Word中的自动调整功能

要使用自动调整功能自动调整Microsoft Word中的表格大小：

1. 右键单击所需表格内的任何位置。
2. 从弹出菜单中选择AutoFit。
3. 选择所需的自动调整选项
   • AutoFit to Contents适合围绕内容的表格。
   • AutoFit to Window调整表格的大小，使其填充左右边距之间的可用页面宽度。
   • 固定列宽度将每个列宽设置为绝对值。这意味着即使单元格内的内容发生变化，表格中每列的宽度也会保持不变。

Aspose.Words中的表格

加载到Aspose.Words中的任何文档中的表都作为表节点导入。表可以作为主体文本的子元素，内容故事（如注释或脚注）或单元格内的嵌套表格来查找。此外，表可以嵌套在其他表中，直到任何深度。一个表节点不包含任何实际的内容-取而代之的则是其他这些节点从而弥补了内容物的容器：

• 表包含许多Row节点。表公开了节点的所有普通成员，允许您自由移动，修改和删除文档中的表。
• A Row表示表的单行，包含许多Cell节点。此外，一行提供了定义行显示方式的成员，例如高度和对齐方式。
• Cell包含在表中看到的真实内容，由Paragraph和其他块级节点组成。此外，单元格可以包含其他嵌套表。

通过使用DocumentExplorer检查文档中表节点的结构，可以最好地表示这种关系。同时还可以在上图中看到该文档包含一个表，该表由一行组成，而该行又由两个单元组成。两个单元格中的每一个都包含一个段落，该段落是格式化文本的容器。在Aspose.Words中，所有与表相关的类和属性都包含在Aspose.Words.Tables命名空间中。

                                         欢迎下载|体验更多Aspose文档管理产品  或 加入Aspose技术交流群（761297826）