首页 文章 精选 留言 我的

精选列表

搜索[基础模型],共10000篇文章
优秀的个人博客,低调大师

JS基础知识整合

1、执行环境:有时也叫环境,是JavaScript中最为重要的一个概念,执行环境定义了变量或函数有权访问的其他数据。 2、变量对象:每一个执行环境都有一个与之关联的变量对象,环境中定义的所有的变量和函数都保存在这个的对象中。 3、作用域链:代码在环境中执行时,会创建变量对象的作用域链,保证对执行环境有权访问的所有变量和函数的有序访问。作用域链的前端,始终是当前执行代码所在环境的变量对象。 4、活动对象:如果当前执行环境是函数,则将活动对象作为变量对象。 5、可执行代码: 1)全局代码:例如加载外部的JS文件或者本地标签内的代码,全局代码不包括function体内的代码; 2)函数代码:function体内的代码; 3) eval代码:eval()函数计算某个字符串,并执行其中的JS代码,比如 eval("alert('helloworld')")。 6、执行上下文栈:在一个JS程序中,必定会产生多个执行上下文,JS引擎会以栈的方式来处理它们,也就是执行上下文栈。 7、作用域:JS是一种没有块级作用域的语言(包括if、for等语句的花括号代码块或者单独的花括号代码块都不能形成一个局部作用域),所以js的局部作用域的形成有且只有函数的花括号内定义的代码块形成的,既函数作用域。 8、作用域链:是作用域规则的实现,通过作用域链的实现,变量在它的作用域内可被访问,函数在它的作用域内可被调用。 作用域链是一个只能单向访问的链表,这个链表上的每个节点就是执行上下文的变量对象,单向链表的头部(可被第一个访问的节点)始终都是当前正在被调用执行的函数的变量对象(活动对象),尾部始终是全局活动对象。 9、闭包:函数对象可以通过作用域链相互关联起来,函数体内的数据(变量和函数声明)都可以保存在函数作用域内,这种特性在计算机科学文献中被称为“闭包”。 从技术角度来说,JS的函数都是闭包:函数都是对象,都关联到作用域链,函数内数据都被保存在函数作用域内。

优秀的个人博客,低调大师

线程最最基础的知识

Java 多线程系列文章第 5 篇。 什么是线程 试想一下没有线程的程序是怎么样的?百度网盘在上传文件时就无法下载文件了,得等文件上传完成后才能下载文件。这个我们现在看起来很反人性,因为我们习惯了一个程序同时可以进行运行多个功能,而这些都是线程的功劳。 之前的文章 进程知多少 中讲到,为了实现多个程序并行执行,引入了进程概念。现在引入线程是为了让一个程序能够并发执行。 线程的组成 线程ID:线程标识符。 当前指令指针(PC):指向要执行的指令。 寄存器集合:存储单元寄存器的集合。 堆栈:暂时存放数据和地址,一般用来保护断点和现场。 线程与进程区别 线程和进程之间的区别,我觉得可以用这个例子来看出两者的不同,进程就是一栋房子,房子住着 3 个人,线程就是住在房子里的人。进程是一个独立的个体,有自己的资源,线程是在进程里的,多个线程共享着进程的资源。 线程状态 我们看到 Java 源代码里面,线程状态的枚举有如下 6 个。 public enum State { //新建状态 NEW, //运行状态 RUNNABLE, //阻塞状态 BLOCKED, //等待状态 WAITING, //等待状态(区别在于这个有等待的时间) TIMED_WAITING, //终止状态 TERMINATED; } 下面给这 6 个状态一一做下解释。 NEW:新建状态。在创建完 Thread ,还没执行 start() 之前,线程的状态一直是 NEW。可以说这个时候还没有真正的一个线程映射着,只是一个对象。 RUNNABLE:运行状态。线程对象调用 start() 之后,就进入 RUNNABLE 状态,该状态说明在 JVM 中有一个真实的线程存在。 BLOCKED:阻塞状态。线程在等待锁的释放,也就是等待获取 monitor 锁。 WAITING:等待状态。线程在这个状态的时候,不会被分配 CPU,而且需要被显示地唤醒,否则会一直等待下去。 TIMED_WAITING:超时等待状态。这个状态的线程也一样不会被分配 CPU,但是它不会无限等待下去,有时间限制,时间一到就停止等待。 TERMINATED:终止状态。线程执行完成结束,但不代表这个对象已经没有了,对象可能还是存在的,只是线程不存在了。 线程既然有这么多个状态,那肯定就有状态机,也就是在什么情况下 A 状态会变成 B 状态。下面就来简单描述一下。 结合下图,我们 new 出线程类的时候,就是 NEW 状态,调用 start() 方法,就进入了 RUNNABLE 状态,这时如果触发等待,则进入了 WAITING 状态,如果触发超时等待,则进入 TIMED_WAITING 状态,当访问需要同步的资源时,则只有一个线程能访问,其他线程就进入 BLOCKED 状态,当线程执行完后,进入 TERMINATED 状态。 其实在 JVM 中,线程是有 9 个状态,如下所示,有兴趣的同学可以深入了解一下。 javaClasses.hpp enum ThreadStatus { NEW = 0, RUNNABLE = JVMTI_THREAD_STATE_ALIVE + // runnable / running JVMTI_THREAD_STATE_RUNNABLE, SLEEPING = JVMTI_THREAD_STATE_ALIVE + // Thread.sleep() JVMTI_THREAD_STATE_WAITING + JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT + JVMTI_THREAD_STATE_SLEEPING, IN_OBJECT_WAIT = JVMTI_THREAD_STATE_ALIVE + // Object.wait() JVMTI_THREAD_STATE_WAITING + JVMTI_THREAD_STATE_WAITING_INDEFINITELY + JVMTI_THREAD_STATE_IN_OBJECT_WAIT, IN_OBJECT_WAIT_TIMED = JVMTI_THREAD_STATE_ALIVE + // Object.wait(long) JVMTI_THREAD_STATE_WAITING + JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT + JVMTI_THREAD_STATE_IN_OBJECT_WAIT, PARKED = JVMTI_THREAD_STATE_ALIVE + // LockSupport.park() JVMTI_THREAD_STATE_WAITING + JVMTI_THREAD_STATE_WAITING_INDEFINITELY + JVMTI_THREAD_STATE_PARKED, PARKED_TIMED = JVMTI_THREAD_STATE_ALIVE + // LockSupport.park(long) JVMTI_THREAD_STATE_WAITING + JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT + JVMTI_THREAD_STATE_PARKED, BLOCKED_ON_MONITOR_ENTER = JVMTI_THREAD_STATE_ALIVE + // (re-)entering a synchronization block JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER, TERMINATED = JVMTI_THREAD_STATE_TERMINATED }; Java 线程实现 下面讲一讲在 Java 中如何创建一个线程。众所周知,实现 Java 线程有 2 种方式:继承 Thread 类和实现 Runnable 接口。 继承 Thread 类 继承 Thread 类,重写 run() 方法。 class MyThread extends Thread { @Override public void run() { System.out.println("MyThread"); } } 实现 Runnable 接口 实现 Runnable 接口,实现 run() 方法。 class MyRunnable implements Runnable { public void run() { System.out.println("MyRunnable"); } } 这 2 种线程的启动方式也不一样。MyThread 是一个线程类,所以可以直接 new 出一个对象出来,接着调用 start() 方法来启动线程;而 MyRunnable 只是一个普通的类,需要 new 出线程基类 Thread 对象,将 MyRunnable 对象传进去。 下面是启动线程的方式。 public class ThreadImpl { public static void main(String[] args) { MyThread myThread = new MyThread(); Thread myRunnable = new Thread(new MyRunnable()); System.out.println("main Thread begin"); myThread.start(); myRunnable.start(); System.out.println("main Thread end"); } } 打印结果如下: main Thread begin main Thread end MyThread MyRunnable 看这结果,不像咱们之前的串行执行依次打印,主线程不会等待子线程执行完。 敲重点:不能直接调用 run(),直接调用 run() 不会创建线程,而是主线程直接执行 run() 的内容,相当于执行普通函数。这时就是串行执行的。看下面代码。 public class ThreadImpl { public static void main(String[] args) { MyThread myThread = new MyThread(); Thread myRunnable = new Thread(new MyRunnable()); System.out.println("main Thread begin"); myThread.run(); myRunnable.run(); System.out.println("main Thread end"); } } 打印结果: main Thread begin MyThread MyRunnable main Thread end 从结果看出只是串行的,但看不出没有线程,我们看下面例子来验证直接调用 run() 方法没有创建新的线程,使用 VisualVM 工具来观察线程情况。 我们对代码做一下修改,加上 Thread.sleep(1000000) 让它睡眠一段时间,这样方便用工具查看线程情况。 调用 run() 的代码: public class ThreadImpl { public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.setName("MyThread"); Thread myRunnable = new Thread(new MyRunnable()); myRunnable.setName("MyRunnable"); System.out.println("main Thread begin"); myThread.run(); myRunnable.run(); System.out.println("main Thread end"); try { Thread.sleep(1000000); } catch (InterruptedException e) { e.printStackTrace(); } } } class MyThread extends Thread { @Override public void run() { System.out.println("MyThread"); try { Thread.sleep(1000000); } catch (InterruptedException e) { e.printStackTrace(); } } } class MyRunnable implements Runnable { public void run() { System.out.println("MyRunnable"); try { Thread.sleep(1000000); } catch (InterruptedException e) { e.printStackTrace(); } } } 运行结果: main Thread begin MyThread 只打印出 2 句日志,观察线程时也只看到 main 线程,没有看到 MyThread 和 MyRunnable 线程,印证了上面咱们说的:直接调用 run() 方法,没有创建线程。 下面我们来看看有 调用 start() 的代码: public class ThreadImpl { public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.setName("MyThread"); Thread myRunnable = new Thread(new MyRunnable()); myRunnable.setName("MyRunnable"); System.out.println("main Thread begin"); myThread.start(); myRunnable.start(); System.out.println("main Thread end"); try { Thread.sleep(1000000); } catch (InterruptedException e) { e.printStackTrace(); } } } 运行结果: main Thread begin main Thread end MyThread MyRunnable 所有日志都打印出来了,并且通过 VisualVM 工具可以看到 MyThread 和 MyRunnable 线程。看到了这个结果,切记创建线程要调用 start() 方法。 今天就先讲到这,继续关注后面的内容。 推荐阅读 老板叫你别阻塞了 吃个快餐都能学到串行、并行、并发 泡一杯茶,学一学同异步 进程知多少? 设计模式看了又忘,忘了又看? 后台回复『设计模式』可以获取《一故事一设计模式》电子书 觉得文章有用帮忙转发&点赞,多谢朋友们!

优秀的个人博客,低调大师

Java基础之反射整理

什么是反射? Java反射就是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;并且能改变它的属性。而这也是Java被视为动态(或准动态,为啥要说是准动态,因为一般而言的动态语言定义是程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言。从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是动态语言。)语言的一个关键性质。 为什么需要反射 在运行时检测对象的类型; 动态构造某个类的对象; 检测类的属性和方法; 任意调用对象的方法; 修改构造函数、方法、属性的可见性; 以及其他。 得到Class类的三种方法 1.通过对象调用 getClass() 方法来获取 Li l1 = new Li(); Class c1 = l1.getClass(); 2.直接通过 类名.class 的方式得到,该方法最为安全可靠,程序性能更高 Class c2 = Li.class; 3.通过 Class 对象的 forName() 静态方法来获取,用的最多 Class c3 = Class.forName("com.qq.Li"); Class的方法整理 getName():获得类的完整名字。 getFields():获得类的public类型的属性。 getDeclaredFields():获得类的所有属性。包括private 声明的和继承类 getMethods():获得类的public类型的方法。 getDeclaredMethods():获得类的所有方法。包括private 声明的和继承类 getMethod(String name, Class[] parameterTypes):获得类的特定方法,name参数指定方法的名字,parameterTypes 参数指定方法的参数类型。 getConstructors():获得类的public类型的构造方法。 getConstructor(Class[] parameterTypes):获得类的特定构造方法,parameterTypes 参数指定构造方法的参数类型。 newInstance():通过类的不带参数的构造方法创建这个类的一个对象。

优秀的个人博客,低调大师

Matplotlib基础全攻略

本文来自云栖社区官方钉群“Python技术进阶”,了解相关信息可以关注“Python技术进阶”。 Matplotlib是Python中最流行的绘图库,它模仿MATLAB中的绘图风格,提供了一整套与MATLAB相似的绘图API,通过API,我们可以轻松地绘制出高质量的图形。 1、开场例子 我们以中国银行股票收盘价曲线作为例子来作为开场。首先我们通过pandas导入数据,并提取出收盘价一列: ChinaBank = pd.read_csv('data/ChinaBank.csv',index_col = 'Date') ChinaBank = ChinaBank.iloc[:,1:] ChinaBank.index = pd.to_datetime(ChinaBank.index) Close = ChinaBank.Close 我们来绘制2

优秀的个人博客,低调大师

Javascript基础之-原型(prototype)

首先呢,prototype是对象里的一个内置属性,并且呢,这个属性是对于其他对象的一个引用。所以呢,思考下面的例子: var obj = { a: 2 } var myObj = Object.create(obj); console.log(myObj.a); // 2 console.log(myObj === obj); // false console.log(Object.getPrototypeOf(myObj) === obj); // true Object.getPrototypeOf(myObj).a = 4 console.log(obj.a); // 4 这里可以看到,实际上Object.create()是新建了一个对象,并且这个对象的prototype是obj的一个引用,所以呢,如果咱们直接修改prototype里面的值,原对象也就跟着变了。 很简单吧,那么如果执行如下代码的话,会发生什么呢? myObj.a = 10; 是不是认为,还跟上面那个一样的,obj.a也变成10了呢?实际上不是的,他的运行机制要比咱们想的稍微复杂一点点。 实际上要分三种情况来看: 如果在prototype链上存在这个属性,并且没有标记为只读,那么就会在本对象上新建一个新的同名属性。 如果在prototype链上存在这个属性,并且标记为只读,那么将无法修改已有属性或在本对象上新建一个同名属性,如果是严格模式的话,还会报错。 如果在prototype链上只是存在此setter,那么一定会调用此setter,并不会添加属性到对象上,更不会重新定义这个setter 很枯燥是吧,来看例子,对照着上面的情况,好好的理解一下: var obj = { a: 2, set c(num) { console.log('exec it'); } } var myObj = Object.create(obj); myObj.a = 10; console.log(obj.a); // 2 console.log(myObj.a); // 10 Object.defineProperty(obj, 'b', { value: 3, writable: false }) myObj.b = 10; console.log(myObj.b); // 3 myObj.c = 20; // "exec it" console.log(myObj.c); // undefined 假如上面的已经理解了,那么可以思考下下面的运行结果: var obj = { a: 2 } var myObj = Object.create(obj); console.log(++myObj.a); // 3 console.log(obj.a); // 2 这个在咱们实际的编码中时有发生,看代码是想把a改成3,但是由于上面第一种情况的影响,实际上是新建了一个同名属性3,并且赋值给了myObj。 上面我们谈论的都是普通对象的prototype的一些特性,接下来,咱们就要讲关于new关键字相关的一些知识点了,思考下面的例子 function Foo() {} var a = new Foo(); console.log(Object.getPrototypeOf(a) === Foo.prototype); // true var b = new Foo(); Object.getPrototypeOf(b).saySomething = function () { console.log('say something'); } a.saySomething(); // "say something" 很明显,在new的过程中呢,生成了一个新对象,并且把Foo.prototype引用到了新对象的prototype。那么因为是引用,所以通过b改变其原型上的prototype的值,Foo.prototype里也会跟着改变。 那么new的过程,是不是一定引用的是函数的prototype呢?也不一定,比如说下面的例子。 function Foo() { return { a: 3 } } var a = new Foo(); console.log(Object.getPrototypeOf(a) === Foo.prototype); // false console.log(Object.getPrototypeOf(a) === Object.prototype); // true console.log(a.a); // 3 在这个例子中,由于new的时候,返回的是一个对象,所以最后实际上a最终引用的是Foo最后返回的那个小对象,所以其prototype就是Object.prototype,而不是Foo.prototype 甚至说,Foo.prototype也是可以被改变的,不过在这时候,new出来的对象,其prototype就是被改过的那个对象。 var protoObj = { b: 10 } function Foo() {} Foo.prototype = protoObj; var a = new Foo(); console.log(Object.getPrototypeOf(a) === Foo.prototype); // true console.log(Object.getPrototypeOf(a) === protoObj); // true console.log(a.b); // 10 你看,如果prototypeObj修改了默认的Foo.prototype,所以最后,实际上形成了这么一个引用链:a.prototype => foo.prototype => protoObj=>Object.prototype。 所以说结论吧,在new的时候,实际上执行会包含这么几步, 如果有return并且返回的是一个对象的话,则直接返回return后的那个对象。 反之,则新建一个对象。 并且吧函数的prototype引用到新建对象的prototype中。 所以说,原型,可以理解为我本来对象有一个prototype,引用着其他的对象,当我这个对象的prototype引用了另一个对象的prototype,一般情况会到Object.prototype为止,这样就组成了一个原型链,原型链也就是互相引用的引用链。而这个引用链是可以根据自己的需求去改。 好了,简短的一小节就完事了,如果有不明白的,或者有疏漏的地方,或者有什么地方想和我讨论的,可以留言给我哦。 本文转载自http://www.lht.ren/article/8/

优秀的个人博客,低调大师

Java重点基础:反射机制

一、什么是反射? Java反射说的是在运行状态中,对于任何一个类,我们都能够知道这个类有哪些方法和属性。对于任何一个对象,我们都能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。 二、反射的三种方式 这里需要跟大家说一下,所谓反射其实是获取类的字节码文件,也就是.class文件,那么我们就可以通过Class这个对象进行获取。 1、第一种方式 这个方法其实是Object的一个方法,Class继承了Object,所以我们可以直接使用。 public class Test02 { public static void main(String\[\] args) { // 创建一个对象 Test02 t = new Test02(); // 获取该对象的Class对象 Class c = t.getClass(); // 获取类名称 System.out.println(c.getName()); // com.ms.Test02 } } 2、第二种方式 public class Test02 { public static void main(String\[\] args) { Class c = Test02.class; // 获取类名称 System.out.println(c.getName()); // com.ms.Test02 } } 3、第三种 这里需要注意,通过类的全路径名获取Class对象会抛出一个异常,如果根据类路径找不到这个类那么就会抛出这个异常。 public class Test02 { public static void main(String\[\] args) { try { // 根据类的全路径名获取 Class c = Class.forName("com.ms.Test02"); // 获取类名称 System.out.println(c.getName()); // com.ms.Test02 } catch (ClassNotFoundException e) { e.printStackTrace(); } } } 那么这3中方式我们一般选用哪种方式呢?第一种已经创建了对象,那么这个时候就不需要去进行反射了,显得有点多此一举。第二种需要导入类的包,依赖性太强。所以我们一般选中第三种方式。 三、通过反射获取类的构造方法、方法以及属性 1、获取构造方法 public class Test01 { public static void main(String\[\] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException { // 加载Class对象 Class c = Class.forName("com.reflect.User"); System.out.println("===========================获取所有公用的构造方法=============================="); // 获取所有公用的构造方法 Constructor\[\] constructors = c.getConstructors(); for (Constructor constructor : constructors) { System.out.println(constructor); } System.out.println("=============================获取所有的构造方法============================"); // 获取所有的构造方法 Constructor\[\] declaredConstructors = c.getDeclaredConstructors(); for (Constructor declaredConstructor : declaredConstructors) { System.out.println(declaredConstructor); } System.out.println("=============================获取公有 & 无参的构造方法============================"); Constructor constructor = c.getConstructor(null); System.out.println(constructor); System.out.println("=============================获取公有 & 有参的构造方法============================"); Constructor constructor1 = c.getConstructor(new Class\[\]{String.class, Integer.class, String.class}); System.out.println(constructor1); System.out.println("=============================获取私有 & 有参 构造方法============================"); Constructor declaredConstructor1 = c.getDeclaredConstructor(new Class\[\]{String.class}); System.out.println(declaredConstructor1); } } 结果: 2、获取类属性 public class Test02 { public static void main(String\[\] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException { // 获取Class对象 Class<?> clazz = Class.forName("com.reflect.User"); System.out.println("=====获取所有的公共字段====="); Field\[\] fields = clazz.getFields(); for (Field field : fields) { System.out.println(field); } System.out.println("=====获取所有的字段(公开的、私有的)====="); Field\[\] declaredFields = clazz.getDeclaredFields(); for (Field declaredField : declaredFields) { System.out.println(declaredField); } System.out.println("=====获取公有字段并使用====="); // 获取指定公有字段 Field field = clazz.getField("name"); // 获取一个公有构造方法,然后实例化 Object obj = clazz.getConstructor().newInstance(); // 为属性设置值 field.set(obj, "张三"); // 测试,看设置的值是否成功 User user = (User) obj; System.out.println(user.getName()); System.out.println("=====获取私有字段并使用====="); Field field1 = clazz.getDeclaredField("sex"); // 获取构造函数,实例化对象 Object obj1 = clazz.getConstructor().newInstance(); // 暴力反射 field1.setAccessible(true); // 给属性设置值 field1.set(obj1, "男"); // 测试 User u = (User) obj1; System.out.println(u.getSex()); } } 结果 这里需要注意,在获取私有属性的时候如果没有进行暴力反射,那么会抛出下面这个异常。 3、获取类中的方法 先定义几个方法 public void method1(String str) { System.out.println("public 修饰的方法"); } private void method2() { System.out.println("private 修饰的方法"); } String method3(String name, Integer age, String sex) { System.out.println("默认修饰 " + name + " " + sex + " " + age + "岁"); return name + sex + age; } protected void method4() { System.out.println("protected 修饰的方法"); } 正题 public class Test03 { public static void main(String\[\] args) throws Exception { // 获取Class对象 Class<?> clazz = Class.forName("com.reflect.User"); System.err.println("======获取所有的public修饰的方法====="); Method\[\] methods = clazz.getMethods(); for (Method method : methods) { System.out.println(method); } Thread.sleep(1000); System.err.println("======获取所有的方法====="); Method\[\] declaredMethods = clazz.getDeclaredMethods(); for (Method declaredMethod : declaredMethods) { System.out.println(declaredMethod); } Thread.sleep(1000); System.err.println("======获取特定方法(带参)并使用====="); Method method1 = clazz.getMethod("method1", String.class); System.out.println(method1); Thread.sleep(1000); System.err.println("======获取特定方法(不带参)并使用====="); Method method2 = clazz.getDeclaredMethod("method2"); System.out.println(method2); System.err.println("======获取特定方法(多个参数)并使用====="); Method method3 = clazz.getDeclaredMethod("method3", String.class, Integer.class, String.class); // 获取构造方法,实例化一个对象 Object obj = clazz.getConstructor().newInstance(); // 给方法传值 Object invoke = method3.invoke(obj, "小涛", 24, "男"); // 测试 System.out.println(invoke); } } 结果 这里需要注意的就是当一个方法需要传入多个参数值的时候,一定要注意。踩了一点坑。 四、反射执行main方法 public class Main { public static void main(String\[\] args) { System.out.println("main方法执行了"); } } 反射调用 public class Test04Main { public static void main(String\[\] args) { try { // 获取Class对象 Class<?> clazz = Class.forName("com.reflect.Main"); // 获取Main方法 Method method = clazz.getMethod("main", java.lang.String\[\].class); // 调用 method.invoke(null, (Object) new String\[\]{"a"}); } catch (Exception e) { e.printStackTrace(); } } } 这里需要告诉大家,在导String包的时候千万要看清楚,我在这填了20多分钟的坑。 五、总结 看到这里你已经对反射有了一个简单的了解,可以使用反射获取一些属性方法,其实我们平时写代码很少用到反射技术,但是在我们使用的一些主流框架中反射技术应用是非常广泛的,所以学好反射也是非常有必要的。 今天就写到这里,下篇给大家分享一下利用反射做一些有应用型的例子。 感觉不错就给小涛一个赞吧!

优秀的个人博客,低调大师

Python基础(面向对象编程)

类的内置方法 补充: 其实比如str()这个内置函数,都是在内部调用__str__方法。 之所以提供str()这种方法大概是更简洁吧,有兴趣的可以去看一下源码。 str(123456)实际上是123456.__str__() 实例: a = 123456 b = str(123456) c = a.__str__ print(b) # 输出123456,看不出是字符串类型,你可以type()下 print(c) # 输出一个内存地址,也就是存放这个字符串的内存地址 print(c()) # 输出123456,用一个内存地址加上一个括号就是执行 print(repr(b)) # 利用repr方法输出 '123456',可以看出是字符串类型,同时你也可以type() print(repr(c())) # 同上,输出 '123456' __str__ class A: def __str__(self): return '我是__str__方法' a = A() print(a) 输出:我是__str__方法 你会觉得不可思议吧,但是确确实实是这样,当我们输出a的时候,实际上是输出a.__str__()方法,友谊之前我们没有写这个方法,所以就会调用object中的__str__方法,因为所有没有继承的类,默认是继承object类的,在子类中没有找到__str__方法就会去父类object中找。 列表实例化输出: list = [1,2,3,4,5] print(list) #那么这里为什么会直接输出一个列表,而不是一个内存地址,实际上就是重构了__str__方法。 注:返回值必须为字符串类型 __repr__ class Person: def __init__(self,name): self.name = name def __repr__(self): return self.name p = Person('张三') print(repr(p)) # 输出 张三 print('我的名字是%r'%p) # 输出 我的名字是张三 %r就是调用的__repr__()方法,同理%s?你应该懂吧。如果我们不写repr方法,它就会调用父类的方法,会输出一个内存地址。 注:当我们在类中写了repr方法,没有写str方法,我们再次输出str(Person)他不会输出内存地址,会输出repr中的内容,我们理解为他找不到str方法就会找repr方法,repr方法再没有就会输出内存地址,但是反过来不行。(莫名的备胎)这个repr方法也必须返回字符串。 __del__ class A: def __init__(self,name): self.name = name def __del__(self): print('执行__del__方法') a = A('张三') del a.name print(a.name) 输出: 'A' object has no attribute 'name' 执行__del__方法 报错了,说明删除了name这个属性,并且执行力__del__中的方法。和上面两个不一样。 注:放我们调用完这个一会执行__del__方法,但是没有删除变量。python这个方法内部有个引用计数机制, 当计数为0的时候,就会删除这个属性。来释放内存。 实例: class A: def __init__(self,name): self.name = name def __del__(self): print('执行__del__方法') a = A('张三') import time time.sleep(1) print(a.name) 输出: 张三 执行__del__方法 可以看到,我们并没有调用__del__方法,但是再调用完之后会自动调用这个方法。并且看一下执行顺序,也就是说,先输出,再调用__del__方法。也就是说先执行__del__中的方法,再进行删除,也就是说我们可以在__del__写一些收尾工作,比如f.close()。 __call__ class A: def __call__(self): print('执行了__call__方法') a = A() a() 输出:执行了__call__方法 也就是a()就是执行了__call__方法。 __getitem__ class A: def __init__(self,name,age): self.name = name self.age = age def __getitem__(self,item): return self.__dict__[item] a = A('张三',18) print(a['name']) 输出:张三 我们实例化之类后,a['name'],就是调用内置方法__getitem__中的内容。 __setitem__ class A: def __init__(self,name,age): self.name = name self.age = age def __setitem__(self,key,value): self.__dict__[key] = value a = A('张三',18) a['sex'] = '男' print(a.sex) 输出:男 也同样,当我们a['sex'] = '男'的时候,调用的是 __setitem__方法。 __delitem__ class A: def __init__(self,name,age): self.name = name self.age = age def __delitem__(self,key): del self.__dict__[key] a = A('张三',18) del a['name'] 这样就删除了,其实我会觉得像删除不是有方法吗,这种方法是以将对象以字典的形式查,那么对于字典和列表你可能又有了新的认识。在object中对应的是__delattr__方法。 __new__ 我们知道__init__是在实例化的时候就会执行,在他之前会执行__new__方法。 class A: def __init__(self,name,age): self.name = name self.age = age def __new__(cls,*args,**kwargs): return object.__new__(A,*args,**kwargs) __new__可以决定调用哪个类的_init_方法,如果有两个类,并且是继承关系,就可以选择调用父类的__init__方法,__init__的self就是__new__实例化的结果。有兴趣的可以去了解一下。 __eq__ class A: def __init__(self,name): self.name =name def __eq__(self,other): return self == other a = A('张三') b = A('张三') print(a==b) 返回False,==是调用了__eq__方法,修改成: def __eq__(self,other): return True 就会返回True,但是也不能这样写是吧,我们判断名字相等就让他返回True def __eq__(self,other): if self.name == other.name: return True else: return False 即可。 __hash__ 在hash()一个类的时候,就会执行__hash__方法。就不多说了。 原文发布时间为:2018-11-29 本文作者:小新python入门到放弃 本文来自云栖社区合作伙伴“Python爱好者社区”,了解相关信息可以关注“python_shequ”微信公众号

优秀的个人博客,低调大师

python基础----动态导入模块

动态导入模块方法1: import 说明: 1. 函数功能用于动态的导入模块,主要用于反射或者延迟加载模块。 2. __import__(module)相当于import module 举例说明: 首先创建一个模块目录lib,然后在目录内创建一个模块为:aa.pyos.path---->lib/aa.py 模块代码为: class c(object): def __str__(self): return 'C language' 在lib目录平级新建一个测试的模块,使用 import 动态以字符串形式导入lib下的aa模块。 lib = __import__('lib.aa') # 相当于import libc = lib.aa.c()print(c) 动态导入模块方法2:import importlib 实例还是上面的lib.aa模块,这里使用importlib进行动态导入(这个方法好理解,也是官方建议使用的) import importlibaa = importlib.import_module('lib.aa')c = aa.c()print(c)

优秀的个人博客,低调大师

Spring Cloud Config 基础示例

Spring Cloud Config 简介 什么是Srping Cloud Config? Spring Cloud Config 是一种分布式配置中心框架, 为分布式系统中的外部化配置提供服务器和客户端支持。(同类技术还有vault,zookeeper,Consul) 使用Config Server,可以在所有环境中管理应用程序的外部属性。客户端和服务器上的概念映射与Spring Environment和PropertySource抽象,因此它们非常适合Spring应用程序,但可以与任何语言运行的任何应用程序一起使用。当应用程序通过部署管道从开发到测试并进入生产时,您可以管理这些环境之间的配置,并确保应用程序具有迁移时需要运行的所有内容。服务器存储后端的默认实现使用git,因此它可以轻松支持配置环境的标记版本,以及可用于管理内容的各种工具。 Spring Cloud Config也主要由两部分组成: Config-Server: 用于配置外部的资源文件,支持对属性值进行加解密 Config-client:绑定到config server使用远程配置文件初始化spring,支持对属性值进行加解密 本文示例说明 为了更直观的理解spring cloud config,本文通过server获取整个配置,效果上与通过配置springboot的active 来切换环境一致;通过接口查询数据库以查看效果; 采用高可用架构;此处使用eureka去做服务注册发现(暂时也只会这个。。),eureka配置说明可以查看springCloud之eureka 新建ConfigServer 为了减少文章长度,尽量干货,创建过程就不截说明了,建议使用Intellij idea进行创建; POM文件: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.lc.springcloud</groupId> <artifactId>config-server</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>config-server</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.0.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> <spring-cloud.version>Greenwich.M2</spring-cloud.version> </properties> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-config-server</artifactId> </dependency> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>${spring-cloud.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> <repositories> <repository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </repository> </repositories> </project> application.yml配置如 server: port: 8100 spring: application: name: config-server cloud: config: server: git: uri: https://github.com/lvchaogit/SpringCloud eureka: client: service-url: defaultZone: http://localhost:8081/eureka/ # 服务注册中心地址 通过配置不难理解,该配置是从git上获取配置,更多配置后续详解; application.java @SpringBootApplication @EnableConfigServer @EnableDiscoveryClient public class ConfigServerApplication { public static void main(String[] args) { SpringApplication.run(ConfigServerApplication.class, args); } } 主要是加上** @EnableConfigServer**注解,开启configserver功能 搭建 Config Client POM文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.lc.springcloud</groupId> <artifactId>config-client</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>config-client</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.0.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> <spring-cloud.version>Greenwich.M2</spring-cloud.version> </properties> <dependencies> <!-- config starter begin--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-config</artifactId> </dependency> <!-- config starter end--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> <version>2.5.0</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.10</version> </dependency> <!-- mybatis-plus begin --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>2.1.9</version> <exclusions> <exclusion> <artifactId>tomcat-jdbc</artifactId> <groupId>org.apache.tomcat</groupId> </exclusion> </exclusions> </dependency> <!--config监控模块 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.13</version> <scope>runtime</scope> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </dependency> </dependencies> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>${spring-cloud.version}</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> <repositories> <repository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </repository> </repositories> </project> bootstrap.yml spring: application: name: config-client cloud: config: profile: dev label: master discovery: enabled: true service-id: config-server server: port: 2001 eureka: client: register-with-eureka: false #因此处只是消费,不提供服务,所以不需要向eureka server注册 service-url: defaultZone: http://localhost:8081/eureka/ # 服务注册中心地址 首先注意配置文件名称为:bootstartp.yml,并不是~~application.yml~~ 通过配置discovery,并设置enabled为true,使client通过服务发现去获取server,server-id为注册中心里配置的服务名称 label=git的标签;profile=配置文件版本(类似于spring boot中的active) 常用configserver配置 采用URI占位符 spring: cloud: config: server: git: uri: https://github.com/lvchaogit/{application} 使用{application} 和 {profile}(如果使用{label},请记住它是使用在git标签中的)。因此你可以轻松的支持“一个应用一个仓库”的原则 模式匹配和多仓库 spring: cloud: config: server: git: uri: https://github.com/lvchaogit/SpringCloud repos: simple: https://github.com/simple/config-repo special: pattern: special*/dev*,*special*/dev* uri: https://github.com/special/config-repo local: pattern: local* uri: file:/home/configsvc/config-repo 在{application}和{profile}参数中使用模式匹配可以支持更多复杂的需求。模式的格式是一组逗号分隔的{application}/{profile},其中的参数可以使用通配符. 如果{application}/{profile}没有匹配到任何模式,它将使用默认的仓库地址:spring.cloud.config.server.git.uri。上面的例子中,"simple"仓库匹配的是“simple/”(它仅仅匹配一个仓库simple,在所有的环境下)。"local"仓库将匹配所有{application}的名字以“local”开头的,并且也是在所有的环境下。“/”前缀自动添加到所有没有设置{profile}的模式中。 匹配仓库子目录 spring: cloud: config: server: git: uri: https://github.com/spring-cloud-samples/config-repo searchPaths: foo,bar* 在foo和以bar开头的目录中,搜索配置文件。 克隆远程的仓库 spring: cloud: config: server: git: uri: https://git/common/config-repo.git repos: team-a: pattern: team-a-* cloneOnStart: true uri: http://git/team-a/config-repo.git team-b: pattern: team-b-* cloneOnStart: false uri: http://git/team-b/config-repo.git team-c: pattern: team-c-* uri: http://git/team-a/config-repo.git 服务器默认在第一次请求配置文件时克隆远程的仓库,也可以配置在启动的时候克隆仓库 team-a的仓库将在服务端启动时进行克隆,其他的仓库将在第一次请求时克隆。 仓库认证 spring: cloud: config: server: git: uri: https://github.com/spring-cloud-samples/config-repo username: trolley password: strongpassword 输入用户名密码 常用配置参考:configServer常用配置 文中示例代码:SpringCloudConfig 示例

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长,特征是大鼻子、头戴帽子、身穿背带裤,还留着胡子。与他的双胞胎兄弟路易基一起,长年担任任天堂的招牌角色。

腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题,腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构,目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring

Spring框架(Spring Framework)是由Rod Johnson于2002年提出的开源Java企业级应用框架,旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念,提供核心容器、应用上下文、数据访问集成等模块,支持整合Hibernate、Struts等第三方框架,其适用范围不仅限于服务器端开发,绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux

Rocky Linux(中文名:洛基)是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版,作为CentOS稳定版停止维护后与RHEL(Red Hat Enterprise Linux)完全兼容的开源替代方案,由社区拥有并管理,支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性,采用模块化包装和SELinux安全架构,默认包含GNOME桌面环境及XFS文件系统,支持十年生命周期更新。

用户登录
用户注册