寂寞先生

Spring学习笔记：AOP

2017-12-20T00:00:00+08:00

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。

不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP技术恰恰相反，它利用一种称为”横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为”Aspect”，即切面。所谓”切面”，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

使用”横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

AOP的基本概念

(1)Aspect(切面):通常是一个类，里面可以定义切入点和通知

(2)JointPoint(连接点):程序执行过程中明确的点，一般是方法的调用

(3)Advice(通知):AOP在特定的切入点上执行的增强处理，有before,after,afterReturning,afterThrowing,around

(4)Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式

(5)weave（织入）:织入是把切面应用到目标对象并创建新的代理对象的过程

(6)introduction（引入）:引入允许我们向现有的类添加新方法或属性

(5)AOP代理：AOP框架创建的对象，代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理，也可以是CGLIB代理，前者基于接口，后者基于子类

Spring AOP

Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。因此，AOP代理可以直接使用容器中的其它bean实例作为目标，这种关系可由IOC容器的依赖注入提供。Spring创建代理的规则为：

1、默认使用Java动态代理来创建AOP代理，这样就可以为任何接口实例创建代理了

2、当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理，也可强制使用CGLIB

AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：

1、定义普通业务组件

2、定义切入点，一个切入点可能横切多个业务组件

3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作

基于注解的AOP配置方式

1.启用@AsjectJ支持

在applicationContext.xml中配置下面一句:

<aop:aspectj-autoproxy />

2.通知类型介绍

(1)Before:在目标方法被调用之前做增强处理,@Before只需要指定切入点表达式即可

(2)AfterReturning:在目标方法正常完成后做增强,@AfterReturning除了指定切入点表达式后，还可以指定一个返回值形参名returning,代表目标方法的返回值

(3)AfterThrowing:主要用来处理程序中未处理的异常,@AfterThrowing除了指定切入点表达式后，还可以指定一个throwing的返回值形参名,可以通过该形参名来访问目标方法中所抛出的异常对象

(4)After:在目标方法完成之后做增强，无论目标方法时候成功完成。@After可以指定一个切入点表达式

(5)Around:环绕通知,在目标方法完成前后做增强处理,环绕通知是最重要的通知类型,像事务,日志等都是环绕通知,注意编程中核心是一个ProceedingJoinPoint

3.例子：

首先编写一个切面类：

@Component
@Aspect
public class Operator {
    
    @Pointcut("execution(* com.aijava.springcode.service..*.*(..))")
    public void pointCut(){}
    
    @Before("pointCut()")
    public void doBefore(JoinPoint joinPoint){
        System.out.println("AOP Before Advice...");
    }
    
    @After("pointCut()")
    public void doAfter(JoinPoint joinPoint){
        System.out.println("AOP After Advice...");
    }
    
    @AfterReturning(pointcut="pointCut()",returning="returnVal")
    public void afterReturn(JoinPoint joinPoint,Object returnVal){
        System.out.println("AOP AfterReturning Advice:" + returnVal);
    }
    
    @AfterThrowing(pointcut="pointCut()",throwing="error")
    public void afterThrowing(JoinPoint joinPoint,Throwable error){
        System.out.println("AOP AfterThrowing Advice..." + error);
        System.out.println("AfterThrowing...");
    }
    
    @Around("pointCut()")
    public void around(ProceedingJoinPoint pjp){
        System.out.println("AOP Aronud before...");
        try {
            pjp.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("AOP Aronud after...");
    }
    
}

上面代码中定义了切面类。其中通过@Pointcut注解声明频繁使用的切点表达式。pointCut()方法并无内容，供@Pointcut注解依附

如下定义一个service类：

@Service
public class UserService {
    
    public void add(){
        System.out.println("UserService add()");
    }
    
    public boolean delete(){
        System.out.println("UserService delete()");
        return true;
    }
    
    public void edit(){
        System.out.println("UserService edit()");
        int i = 5/0;
    }
}

下面开始测试：

    public class Test {
        public static void main(String[] args) {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
            UserService userService = (UserService) ctx.getBean("userService");
            userService.add();
        }
    }

上面是一个比较简单的测试，基本涵盖了各种增强定义。上列中进入目标方法add()时会在各个相应切点进行织入，注意:做环绕通知的时候，调用ProceedingJoinPoint的proceed()方法才会执行目标方法。

4.通知执行的优先级

进入目标方法时,先织入Around,再织入Before，退出目标方法时，先织入Around,再织入AfterReturning,最后才织入After。

注意:Spring AOP的环绕通知会影响到AfterThrowing通知的运行,不要同时使用!同时使用也没啥意义。

5.切入点的定义和表达式

切入点表达式的定义算是整个AOP中的核心，有一套自己的规范

Spring AOP支持的切入点指示符：

(1)execution:用来匹配执行方法的连接点：

@Pointcut("execution(* com.aijava.springcode.service..*.*(..))")

第一个表示匹配任意的方法返回值，..(两个点)表示零个或多个，上面的第一个..表示service包及其子包,第二个表示所有类,第三个*表示所有方法，第二个..表示方法的任意参数个数

@Pointcut("within(com.aijava.springcode.service.*)")

within限定匹配方法的连接点,上面的就是表示匹配service包下的任意连接点

@Pointcut("this(com.aijava.springcode.service.UserService)")

this用来限定AOP代理必须是指定类型的实例，如上，指定了一个特定的实例，就是UserService

@Pointcut("bean(userService)")

bean也是非常常用的,bean可以指定IOC容器中的bean的名称

6.基于XML形式的配置方式

例子：首先定义接口

public interface HelloWorld
{
    void printHelloWorld();
    void doPrint();
}

实现接口

public class HelloWorldImpl1 implements HelloWorld
{
    public void printHelloWorld()
    {
        System.out.println("Enter HelloWorldImpl1.printHelloWorld()");
    }
    
    public void doPrint()
    {
        System.out.println("Enter HelloWorldImpl1.doPrint()");
        return ;
    }
}

public class HelloWorldImpl2 implements HelloWorld
{
    public void printHelloWorld()
    {
        System.out.println("Enter HelloWorldImpl2.printHelloWorld()");
    }
    
    public void doPrint()
    {
        System.out.println("Enter HelloWorldImpl2.doPrint()");
        return ;
    }
} 

定义横切关注点：

public class TimeHandler
{
    public void printTime()
    {
        System.out.println("CurrentTime = " + System.currentTimeMillis());
    }
}

编写aop.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
        
        <bean id="helloWorldImpl1" class="com.cf.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.cf.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.cf.aop.TimeHandler" />
        
        <aop:config>
            <aop:aspect id="time" ref="timeHandler">
                <aop:pointcut id="addAllMethod" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="printTime" pointcut-ref="addAllMethod" />
                <aop:after method="printTime" pointcut-ref="addAllMethod" />
            </aop:aspect>
        </aop:config>
</beans>

调用：

public static void main(String[] args)
{
    ApplicationContext ctx = 
            new ClassPathXmlApplicationContext("aop.xml");
        
    HelloWorld hw1 = (HelloWorld)ctx.getBean("helloWorldImpl1");
    HelloWorld hw2 = (HelloWorld)ctx.getBean("helloWorldImpl2");
    hw1.printHelloWorld();
    System.out.println();
    hw1.doPrint();
    
    System.out.println();
    hw2.printHelloWorld();
    System.out.println();
    hw2.doPrint();
}

输出：

CurrentTime = 1446129611993
Enter HelloWorldImpl1.printHelloWorld()
CurrentTime = 1446129611993

CurrentTime = 1446129611994
Enter HelloWorldImpl1.doPrint()
CurrentTime = 1446129611994

CurrentTime = 1446129611994
Enter HelloWorldImpl2.printHelloWorld()
CurrentTime = 1446129611994

CurrentTime = 1446129611994
Enter HelloWorldImpl2.doPrint()
CurrentTime = 1446129611994

Spring学习笔记：注解

2017-12-19T00:00:00+08:00

spring学习笔记

常见注解

@Service用于标注业务层组件、 
@Controller用于标注控制层组件（如struts中的action）
@Repository用于标注数据访问组件，即DAO组件。
@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。不建议使用。

@Primary：自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否则将抛出异常
@Autowired 默认按类型装配，如果我们想使用按名称装配，可以结合@Qualifier注解一起使用。如下：
    @Autowired @Qualifier("personDaoBean") 存在多个实例配合使用
@Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。

@Scope用于指定scope作用域的（用在类上）
@PostConstruct初始化注解,用于指定初始化方法（用在方法上）
@PreDestory摧毁注解 默认 单例  启动就加载,用于指定销毁方法（用在方法上）
@DependsOn：定义Bean初始化及销毁时的顺序

@RequestMapping 这个注解用于将url映射到整个处理类或者特定的处理请求的方法。可以只用通配符！
@RequestParam
@ResponseBody
@RequestBody
@ModelAttribute
@Cacheable
@CacheFlush

@SessionAttributes
@InitBinder
@Required
@Lazy(true) 表示延迟初始化
@Async异步方法调用

定义Bean的注解【@Component/@Repository/@Service/@Controller】

1，xml配置

用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册<context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。如下：

<context:component-scan base-package="cn.gacl.java"/>

表明cn.gacl.java包及其子包中，如果某个类的头上带有特定的注解【@Component/@Repository/@Service/@Controller】，就会将这个对象作为Bean注册进Spring容器。也可以在 base-package=” ” 中指定多个包，多个包逗号隔开。

2，spring 上下文中注册bean

@Component/@Repository/@Service/@Controller 使用方法一样，放在类的头上，这几个注解都是向spring 上下文中注册bean。例如：

@Service("userService")
public class UserServiceImpl implements UserService {
    // to do somethine
}

默认的bean名字为这个类的类名首字母小写，如果指定value【@Service(value=”userService”)】或者【@Service(“userService”)】，则使用value作为bean的名字。 @Component 是所有受Spring 管理组件的通用形式， Spring 还提供了更加细化的注解形式： @Repository 、@Service 、@Controller ，它们分别对应存储层Bean ，业务层Bean ，和展示层Bean 。 @Controller，@Service，@Repository会携带更多语义。尽量考虑使用@Controller，@Service，@Repository代替通用的@Component

http请求注解（spring MVC模块注解）【@RequestMapping/@RequestParam/@PathVariable/@ResponseBody/@RequestBody】

@RequestMapping

@RequestMapping 是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

RequestMapping注解有六个属性：

1、 value， method；

value：指定请求的实际地址，指定的地址可以是URI Template 模式；

method：指定请求的method类型， GET、POST、PUT、DELETE等；

@RequestMapping (value= "testMethod" , method={RequestMethod. GET , RequestMethod. DELETE })
public String testMethod() {
   return "method" ;
}

在上面的代码中就使用method 参数限制了以GET 或DELETE 方法请求/testMethod 的时候才能访问到该Controller 的testMethod 方法。

2、consumes，produces

consumes：指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;

@RequestMapping(value = "pets", method = RequestMethod.POST, consumes="application/json")  
public void addPet(@RequestBody Pet pet, Model model) {      
    // implementation omitted  
}  

produces: 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；

@RequestMapping(value = "pets/{petId}", method = RequestMethod.GET, produces="application/json")  
@ResponseBody  
public Pet getPet(@PathVariable String petId, Model model) {      
    // implementation omitted  
}  

3、params，headers

params：指定request中必须包含某些参数值是，才让该方法处理。

@RequestMapping (value= "testParams" , params={ "param1=value1" , "param2" , "!param3" })
public String testParams() {
   System. out .println( "test Params..........." );
   return "testParams" ;
}

在上面的代码中就使用method 参数限制了以GET 或DELETE 方法请求/testMethod 的时候才能访问到该Controller 的testMethod 方法。

headers：指定request中必须包含某些指定的header值，才能让该方法处理请求。

@RequestMapping (value= "testHeaders" , headers={ "host=localhost" , "Accept" })
public String testHeaders() {
   return "headers" ;
}

headers 属性的用法和功能与params 属性相似。在上面的代码中当请求/testHeaders 的时候只有当请求头包含Accept 信息，且请求的host 为localhost 的时候才能正确的访问到testHeaders 方法。

@RequestParam 、@PathVariable 、@RequestBody 等

handler method 参数绑定常用的注解,我们根据他们处理的Request的不同内容部分分为四类：（主要讲解常用类型）

A、处理requet uri 部分（这里指uri template中variable，不含queryString部分）的注解： @PathVariable;

B、处理request header部分的注解： @RequestHeader, @CookieValue;

C、处理request body部分的注解：@RequestParam, @RequestBody;

D、处理attribute类型是注解： @SessionAttributes, @ModelAttribute;

1、 @PathVariable

当使用@RequestMapping URI template 样式映射时，即 someUrl/{paramId}, 这时的paramId可通过 @Pathvariable注解绑定它传过来的值到方法的参数上。

@Controller  
@RequestMapping("/owners/{ownerId}")  
public class RelativePathUriTemplateController {  
  
  @RequestMapping("/pets/{petId}")  
  public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {      
    // implementation omitted  
  }  
}

上面代码把URI template 中变量 ownerId的值和petId的值，绑定到方法的参数上。若方法参数名称和需要绑定的uri template中变量名称不一致，需要在@PathVariable(“name”)指定uri template中的名称。

2、@RequestParam, @RequestBody

####### @RequestParam 绑定 HttpServletRequest 请求参数到控制器方法参数。

A）常用来处理简单类型的绑定，通过Request.getParameter() 获取的String可直接转换为简单类型的情况；因为使用request.getParameter()方式获取参数，所以可以处理get 方式中queryString的值，也可以处理post方式中 body data的值；

B）用来处理Content-Type: 为 application/x-www-form-urlencoded编码的内容，提交方式GET、POST；

C) 该注解有四个属性： value、required； value绑定本次参数的名称(要跟URL上面的一样)，required用来指示参数是否必须绑定；

//请求url /requestParam?hello=test&age=1
@RequestMapping ( "requestParam" )
public String testRequestParam( @RequestParam(value="hello",required=false) String name, @RequestParam int age) {
    return "requestParam" ;
}

注意:

和@PathVariable 一样，当你没有明确指定从request 中取哪个参数时，默认取更方法参数同名的参数。此外，当需要从request 中绑定的参数和方法的参数名不相同的时候，也需要在@RequestParam 中明确指出是要绑定哪个参数。

####### @RequestBody 该注解常用来处理Content-Type: 不是application/x-www-form-urlencoded编码的内容，例如application/json, application/xml等；

3，@RequestHeader、@CookieValue

@RequestHeader 注解，可以把Request请求header部分的值绑定到方法的参数上。

@CookieValue 可以把Request header中关于cookie的值绑定到方法的参数上。

如下：

@RequestMapping("/displayHeaderInfo.do")  
public void displayHeaderInfo(@RequestHeader("Accept-Encoding") String encoding,  
                              @RequestHeader("Keep-Alive") long keepAlive)  {  
  //...  
} 

@RequestMapping("/displayHeaderInfo.do")  
public void displayHeaderInfo(@CookieValue("JSESSIONID") String cookie)  {  
  //...  
}  

4，@ResponseBody

@ResponseBody：

该注解作用：将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。

使用场景：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；

总结： GET模式下，这里使用了@PathVariable绑定输入参数，非常适合Restful风格。因为隐藏了参数与路径的关系，可以提升网站的安全性，静态化页面，降低恶意攻击风险。 POST模式下，使用@RequestBody绑定请求对象，Spring会帮你进行协议转换，将Json、Xml协议转换成你需要的对象。 @ResponseBody可以标注任何对象，由Srping完成对象——协议的转换。

自动装配Bean【@Primary/@Autowired/@Qualifier/@Resource】

1，@Primary和@Qualifier

首先解释一下@Primary和@Qualifier这两个注解的意思：这两个注解是为了处理自动装配的歧义性，@Primary的意思是在众多相同的bean中，优先使用用@Primary注解的bean.而@Qualifier这个注解则指限定自动装配的bean。

@Primary注解在注册bean是声明，如：

@Component
@Primary
public class Cake implements Dessert{ ... }

当遇到歧义性的时候， Spring将会使用首选的bean，而不是其他可选的bean。实际上，你所声明就是“最喜欢”的bean。

我们可以为bean设置自己的限定符，而不是依赖于将bean ID作为限定符。在这里所需要做的就是在bean声明上添加@Qualifier注解。例如，它可以与@Component组合使用，如下所示：

@Component
@Qualifier("beanName")
public class Cake implements Dessert{ ... }

@Component
@Qualifier("beanName2")
public class Cake implements Dessert{ ... }

使用@Autowired 时，如下所示：

@Autowired
private Dessert dessert;

一个接口Dessert和这个接口的三个实现类，bean找到多个同一类型的bean，则会抛异常，出现如下错误：NoUniqueBeanDefinitionException.

此时可以使用 @Qualifier(“beanName”)，明确指定bean的名称进行注入，此时与 @Resource指定name属性作用相同。如下：

@Autowired
@Qualifier("beanName")
private Dessert dessert;

2，@Autowired和@Resource

@Autowired 为Spring提供的注解

• 例如

@Autowired
private ISoftPMService softPMService;

• 或者

@Autowired(required=false)
private ISoftPMService softPMService;

@Autowired 根据bean 类型从spring 上线文中进行查找，注册类型必须唯一，否则报异常。 @Autowired(required=false) 表示，如果spring 上下文中没有找到该类型的bean 时，则softPMService值为null;

@Resource 由J2EE提供

• 例如

@Resource
private DataSource dataSource; // inject the bean named 'dataSource'

• 或者

@Resource(name="dataSource")
@Resource(type=DataSource.class)
private DataSource dataSource;

@Resource 默认按bean 的name 进行查找，如果没有找到会按type 进行查找，此时与@Autowired 类似.

@Autowired与@Resource 的区别在于：

@Resource 允许通过bean 名称或bean 类型两种方式进行查找，默认使用name查找
@Autowired(required=false) 表示，如果spring 上下文中没有找到该类型的bean 时， 允许为null;

定义Bean的作用域和生命过程

@Scope(“prototype”) 值有:

singleton,prototype,session,request,session,globalSession

singleton：单例模式

Spring IoC容器中只会存在一个共享的Bean实例，无论有多少个Bean引用它，始终指向同一对象。
Singleton作用域是Spring中的缺省作用域，也可以显示的将Bean定义为singleton模式，

prototype:原型模式

prototype:原型模式，每次通过Spring容器获取prototype定义的bean时，容器都将创建一个新的Bean实例，每个Bean实例都有自己的属性和状态，
而singleton全局只有一个对象。根据经验，对有状态的bean使用prototype作用域，而对无状态的bean使用singleton作用域。

request

request：在一次Http请求中，容器会返回该Bean的同一实例。而对不同的Http请求则会产生新的Bean，而且该bean仅在当前Http Request内有效。
针对每一次Http请求，Spring容器根据该bean的定义创建一个全新的实例，且该实例仅在当前Http请求内有效，而其它请求无法看到当前请求中状态的变化，当当前Http请求结束，该bean实例也将会被销毁。

session

session：在一次Http Session中，容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例，该bean实例仅在当前Session内有效。
<bean id="userPreference" class="com.ioc.UserPreference" scope="session"/>,同Http请求相同，每一次session请求创建新的实例，而不同的实例之间不共享属性，且实例仅在自己的session请求内有效，请求结束，则实例将被销毁。
global Session：在一个全局的Http Session中，容器会返回该Bean的同一个实例，仅在使用portlet context时有效。

@PostConstruct 相当于init-method,使用在方法上，当Bean初始化时执行。

@PreDestroy 相当于destory-method，使用在方法上，当Bean销毁时执行。

声明式事务

 @Transactional

php队列 —— rabbitmq

2017-05-14T00:00:00+08:00

lumen中使用rabbitmq

1,安装rabbitMQ驱动库

有很多开源好用的库可以使用，本例子使用 vladimir-yuldashev/laravel-queue-rabbitmq 在项目根目录运行命令：

composer require vladimir-yuldashev/laravel-queue-rabbitmq:5.3

2，注册rabbitMQ服务

在文件 bootstrap/app.php中添加一行：

$app->register(VladimirYuldashev\LaravelQueueRabbitMQ\LaravelQueueRabbitMQServiceProvider::class);

3，配置

修改config/queque.php文件，在Connections中添加：

'rabbitmq' => [
    'driver' => 'rabbitmq',

    'host' => env('RABBITMQ_HOST', '127.0.0.1'),
    'port' => env('RABBITMQ_PORT', 5672),

    'vhost' => env('RABBITMQ_VHOST', '/'),
    'login' => env('RABBITMQ_LOGIN', 'guest'),
    'password' => env('RABBITMQ_PASSWORD', 'guest'),

    'queue' => env('RABBITMQ_QUEUE'), // name of the default queue,
    'exchange_declare' => env('RABBITMQ_EXCHANGE_DECLARE', true), // create the exchange if not exists
    'queue_declare_bind' => env('RABBITMQ_QUEUE_DECLARE_BIND', true), // create the queue if not exists and bind to the exchange

    'queue_params' => [
        'passive' => env('RABBITMQ_QUEUE_PASSIVE', false),
        'durable' => env('RABBITMQ_QUEUE_DURABLE', true),
        'exclusive' => env('RABBITMQ_QUEUE_EXCLUSIVE', false),
        'auto_delete' => env('RABBITMQ_QUEUE_AUTODELETE', false),
    ],

    'exchange_params' => [
        'name' => env('RABBITMQ_EXCHANGE_NAME', null),
        'type' => env('RABBITMQ_EXCHANGE_TYPE', 'direct'), // more info at http://www.rabbitmq.com/tutorials/amqp-concepts.html
        'passive' => env('RABBITMQ_EXCHANGE_PASSIVE', false),
        'durable' => env('RABBITMQ_EXCHANGE_DURABLE', true), // the exchange will survive server restarts
        'auto_delete' => env('RABBITMQ_EXCHANGE_AUTODELETE', false),
    ],

]

在.env文件中配置：

QUEUE_DRIVER=rabbitmq    
RABBITMQ_HOST=172.29.231.70
RABBITMQ_PORT=5672
RABBITMQ_LOGIN=guest
RABBITMQ_PASSWORD=guest

4，使用

创建queque 实例:Jobs目录生成对应文件

php artisan make:job TagJob

内容如下：

    /**
     * Created by PhpStorm.
     * User: cfeng
     * Date: 2016/11/8
     * Time: 9:30
     */
    
    namespace App\Jobs;
    
    use Illuminate\Bus\Queueable;
    use Illuminate\Queue\SerializesModels;
    use Illuminate\Queue\InteractsWithQueue;
    use Illuminate\Contracts\Queue\ShouldQueue;
    use Mockery\CountValidator\Exception;
    use App\Tag;
    
    class TagJob extends Job
    {
    
        private $tags;
    
        /**
         * Create a new job instance.
         *
         * @return void
         */
        public function __construct($tags)
        {
            //消息队里内的数据
            $this->tags = $tags;
        }
    
        /**
         * Execute the job.
         *
         * @return void
         */
        public function handle()
        {
            //处理消息队列数据
            
            //保存tag
            Tag::saveTag($this->tags);
    
        }
    }
    

将数据推送到消息队列中

    $tagJob= (new MetricJobV1($tags))->onQueue("TagJob");
    $this->dispatch($tagJob);

开启消费者监听队列

nohup php artisan queue:work --daemon --queue=TagJob > tagJob.log 2>1 &

具体使用可以参考laravel 文档： https://laravel.com/docs/5.5/queues

linux(centos)系统安装lamp环境

2017-05-02T00:00:00+08:00

一：准备工作
二：安装
二：可能遇到的问题

准备工作：

1,编译安装环境需要gcc，make等编译工具,请确认安装了这些:

yum -y install gcc
yum -y install make
yum -y install build-essential

2,下载必要安装包，也可以使用wget命令直接下载：

apache，mysql，php下载:

apache ： http://mirrors.hust.edu.cn/apache/httpd/httpd-2.4.25.tar.gz
php ： http://jp2.php.net/distributions/php-7.1.4.tar.gz （http://php.net/get/php-7.1.4.tar.gz/from/a/mirror 可以选择不同镜像下载）
mysql ：https://cdn.mysql.com//Downloads/MySQL-5.7/mysql-server_5.7.18-1ubuntu16.10_i386.deb-bundle.tar （https://dev.mysql.com/downloads/mysql/ 选择需要的平台和版本）

apr,apr_unit,apr_icon 下载: (http://apr.apache.org/download.cgi)

apr : http://apache.fayea.com//apr/apr-1.5.2.tar.gz
apr-util : http://apache.fayea.com//apr/apr-util-1.5.4.tar.gz
apr-iconv : http://apache.fayea.com//apr/apr-iconv-1.2.1.tar.gz

pcre下载:

ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-8.40.zip

3,安装依赖包

安装apr,apr_unit,apr_icon,pcre

apr: ./configure --prefix=/usr/local/apr
apr-unit: ./configure --prefix=/usr/local/apr-util -with-apr=/usr/local/apr/bin/apr-1-config
apr-iconv: ./configure --prefix=/usr/local/apr-iconv --with-apr=/usr/local/apr
pcre: ./configure --prefix=/usr/local/pcre

安装apache，mysql，php：

1，apache

[root@localhost lamp]# tar zvxf httpd-2.4.9.tar.bz2

[root@localhost lamp]# cd httpd-2.4.9

[root@localhost httpd-2.4.9]# ./configure 
     --prefix=/usr/local/apache2 \
     --with-included-apr \
     --enable-so \
     --enable-deflate=shared \
     --enable-expires=shared \
     --enable-rewrite=shared \
     --enable-static-support \
     --disable-userdir

[root@localhost httpd-2.4.9]# make

[root@localhost httpd-2.4.9]# make install

2,mysql

1，解压并初始化

[root@localhost lamp]# tar zxvf mysql-5.7.18-linux-glibc2.5-x86_64.tar.gz

[root@localhost lamp]# mv mysql-5.7.18-linux-glibc2.5-x86_64 /usr/local/mysql

[root@localhost lamp]# useradd mysql

[root@localhost lamp]# cd /usr/local/mysql

[root@localhost mysql]# mkdir ./data/mysql 

[root@localhost mysql]# chown -R mysql:mysql ./data/mysql

[root@localhost mysql]# ./scripts/mysql_install_db --user=mysql --datadir=/usr/local/mysql/data/mysql

## user定义数据库的所属主，--datadir定义数据库安装到哪里，建议放到大空间的分区上，这个目录需要自行创建。

2，配置

拷贝配置文件，如果有就覆盖

[root@localhost mysql]# cp support-files/my-large.cnf /etc/my.cnf   ###### 拷贝启动脚本文件并修改配置    
[root@localhost mysql]# cp support-files/mysql.server /etc/init.d/mysqld   
[root@localhost mysql]# chmod 755 /etc/init.d/mysqld 
[root@localhost mysql]# vim /etc/init.d/mysqld
## 需要修改的地方有datadir=/usr/local/mysql/data/mysql（前面初始化数据库时定义的目录） ###### 把启动脚本加入系统服务项，并设定开机启动
[root@localhost mysql]# chkconfig --add mysqld
[root@localhost mysql]# chkconfig mysqld on

3，php

1 安装

[root@localhost lamp]# tar zvxf php-7.1.4.tar.gz
[root@localhost lamp]# cd php-7.1.4
[root@localhost lamp]# ./configure --prefix=/usr/local/php \
    --with-apxs2=/usr/local/apache2/bin/apxs \
    --with-config-file-path=/usr/local/php/etc \ 
    --with-mysql=mysqlnd \
    --with-mysqli=mysqlnd \
    --with-pdo-mysql=mysqlnd \
    --with-gettext \
    --enable-mbstring \ 
    --with-iconv \
    --with-mcrypt \
    --with-mhash \
    --with-openssl \ 
    --enable-bcmath \
    --enable-soap \
    --with-libxml-dir \
    --enable-pcntl \
    --enable-shmop \
    --enable-sysvmsg \
    --enable-sysvsem \
    --enable-sysvshm \
    --enable-sockets \
    --with-curl \
    --with-gd \
    --with-zlib \
    --enable-zip \
    --with-bz2  \
    --without-sqlite3 \
    --without-pdo-sqlite \
    --with-pear \
    --enable-opcache

[root@localhost lamp]# make && make install

2，配置

1,系统配置

[root@localhost lamp]# mkdir /usr/local/php/etc
[root@localhost lamp]# cp php.ini-dist /usr/local/php/etc/php.ini

## 将php mysql添加到系统环境变量，修改/etc/profile文件使其永久性生效，并对所有系统用户生效，在文件末尾加上如下两行代码：
    PATH=$PATH:/usr/local/webserver/php/bin:/usr/local/webserver/mysql/bin
    export PATH
## 最后：执行 命令source /etc/profile或 执行点命令 ./profile使其修改生效，执行完可通过echo $PATH命令查看是否添加成功。 ##### 2，apache结合php配置

Apache主配置文件为

vim /usr/local/apache2/conf/httpd.conf
找到: AddType application/x-gzip .gz .tgz
在该行下面添加: AddType application/x-httpd-php .php
找到:
     <IfModule dir_module>
         DirectoryIndex index.html
     </IfModule>
将该其改为:
     <IfModule dir_module>
         DirectoryIndex index.html index.htm index.php
     </IfModule>
找到: #ServerName www.example.com:80
修改为: ServerName localhost:80

可能遇到的问题：

php编译

出现如下错误:configure: error: xml2-config not found. Please check your libxml2 installation.解决办法是:

yum install -y libxml2-devel

还有错误: configure: error: Cannot find OpenSSL’s 解决办法是:

yum install -y openssl openssl-devel

错误: checking for BZip2 in default path… not foundconfigure: error: Please reinstall the BZip2 distribution 解决办法:

yum install -y bzip2 bzip2-devel

错误:configure: error: png.h not found. 解决办法:

yum install -y libpng libpng-devel

错误:configure: error: freetype.h not found. 解决办法:

yum install -y freetype freetype-devel

错误: configure: error: mcrypt.h not found. Please reinstall libmcrypt. 解决办法:

yum install -y  libmcrypt-devel
因为centos6.x 默认的yum源没有libmcrypt-devel 这个包，只能借助第三方yum源。

以上问题较为常见，处理方法都是相同，根据编译错误提示，安装缺少的依赖。

Javascript 面向对象编程：实例

2016-10-20T00:00:00+08:00

之前介绍了，js面向对象编程的相关内容。本人在实际项目中，也用到js面向对象的编程，不说废话直接上代码。

定义两个实例 AccountItem (用户) AccountList (用列表) ：

//名前空間
var EIMS = EIMS || {};

EIMS.AccountItem = (function(){
	//constructor
	function AccountItem(id, shisha_id, busho_id, name, del_flag){
		this.id = id;
		this.shisha_id = shisha_id;
		this.busho_id = busho_id;
		this.name = name;
		this.del_flag = del_flag;
	}

	//accesser
	AccountItem.prototype.getId = function(){
		return this.id;
	};
	AccountItem.prototype.getShishaId = function(){
		return this.shisha_id;
	}
	AccountItem.prototype.getBushoId = function(){
		return this.busho_id;
	}
	AccountItem.prototype.getName = function(){
		return this.name;
	}
	AccountItem.prototype.getDelFlag = function(){
		return this.del_flag;
	}

	return AccountItem;
})();

EIMS.AccountList = (function(){
	//constructor
	function AccountList(shisha_id, busho_id, del_flag, or_id){
		this.search_shisha_id = shisha_id;
		this.search_busho_id = busho_id;
		this.search_del_flag = del_flag;
		this.search_or_id = or_id;
	}

	AccountList.prototype.getArray = function(url){
		var arr = new Array();
		var params = $H({shisha_id : this.search_shisha_id, busho_id : this.search_busho_id, del_flag : this.search_del_flag, or_id : this.search_or_id});
		var callback_success = function(objXml){
			var id, shisha_id, busho_id, del_flag, name;
			var itemTags = objXml.getElementsByTagName("item");
			for(var i = 0; i < itemTags.length; i ++){
				id = "";
				shisha_id = "";
				busho_id = "";
				del_flag = 0;
				name = "";
				tmp = itemTags[i].firstChild;
				while(tmp != null){
					if(tmp.nodeName.toLowerCase() == "id"){
						if(tmp.firstChild != null) id = tmp.firstChild.nodeValue;
					}else if(tmp.nodeName.toLowerCase() == "shisha_id"){
						if(tmp.firstChild != null) shisha_id = tmp.firstChild.nodeValue;
					}else if(tmp.nodeName.toLowerCase() == "busho_id"){
						if(tmp.firstChild != null) busho_id = tmp.firstChild.nodeValue;
					}else if(tmp.nodeName.toLowerCase() == "del_flag"){
						if(tmp.firstChild != null) del_flag = tmp.firstChild.nodeValue;
					}else if(tmp.nodeName.toLowerCase() == "name"){
						if(tmp.firstChild != null) name = tmp.firstChild.nodeValue;
					}
					tmp = tmp.nextSibling;
				}

				arr.push(new EIMS.AccountItem(id, shisha_id, busho_id, name, del_flag));
			}
		};
		new Ajax.Request(
			url,
			{
				method : 'get',
				asynchronous : false,
				parameters : params,
				onSuccess : function(req){
					callback_success(req.responseXML);
				},
				onFailure : function(req){
					alert(req.responseText.trim());
				},
				onException : function(req, e){
					alert(e.message);
				}
			}
		);

		return arr;
	};

	return AccountList;
})();

使用实例：

    //生成AccountList实例 使用构造函数属性初始化
    var obj = new EIMS.AccountList($("search_shisha_id").value, $("search_busho_id").value, 0, "");

    //调用getArray方法，返回 数组对象
    var arr = obj.getArray(account_list_url);

    //生成AccountItem实例，利用构造函数设置属性值，并将实例插入到数组对象中
    arr.unshift(new EIMS.AccountItem("", "", "", "担当", 1));

以上是项目中实际使用的一段代码，粗浅非常，请多包涵。

Javascript 面向对象编程（三）：非构造函数的继承

2016-10-20T00:00:00+08:00

今天是最后一个部分，介绍不使用构造函数实现”继承”。

一、什么是”非构造函数”的继承？

比如，现在有一个对象，叫做”中国人”。

    var Chinese = {
        nation:'中国'
    };

还有一个对象，叫做”医生”。

    var Doctor ={
        career:'医生'
    };

请问怎样才能让”医生”去继承”中国人”，也就是说，我怎样才能生成一个”中国医生”的对象？

这里要注意，这两个对象都是普通对象，不是构造函数，无法使用构造函数方法实现”继承”。

二、object()方法

json格式的发明人Douglas Crockford，提出了一个object()函数，可以做到这一点。

    function object(o) {
        function F() {}
        F.prototype = o;
        return new F();
    }

这个object()函数，其实只做一件事，就是把子对象的prototype属性，指向父对象，从而使得子对象与父对象连在一起。

使用的时候，第一步先在父对象的基础上，生成子对象：

    var Doctor = object(Chinese);

然后，再加上子对象本身的属性：

    Doctor.career = '医生';

这时，子对象已经继承了父对象的属性了。

    alert(Doctor.nation); //中国

三、浅拷贝

除了使用”prototype链”以外，还有另一种思路：把父对象的属性，全部拷贝给子对象，也能实现继承。

下面这个函数，就是在做拷贝：

    function extendCopy(p) {
        var c = {};
        for (var i in p) {
            c[i] = p[i];
        }
        c.uber = p;
        return c;
    }

使用的时候，这样写：

    var Doctor = extendCopy(Chinese);
    Doctor.career = '医生';
    alert(Doctor.nation); // 中国

但是，这样的拷贝有一个问题。那就是，如果父对象的属性等于数组或另一个对象，那么实际上，子对象获得的只是一个内存地址，而不是真正拷贝，因此存在父对象被篡改的可能。

请看，现在给Chinese添加一个”出生地”属性，它的值是一个数组。

    Chinese.birthPlaces = ['北京','上海','香港'];

通过extendCopy()函数，Doctor继承了Chinese。

    var Doctor = extendCopy(Chinese);

然后，我们为Doctor的”出生地”添加一个城市：

    Doctor.birthPlaces.push('厦门');

发生了什么事？Chinese的”出生地”也被改掉了！

    alert(Doctor.birthPlaces); //北京, 上海, 香港, 厦门
    alert(Chinese.birthPlaces); //北京, 上海, 香港, 厦门

所以，extendCopy()只是拷贝基本类型的数据，我们把这种拷贝叫做”浅拷贝”。这是早期jQuery实现继承的方式。

四、深拷贝

所谓”深拷贝”，就是能够实现真正意义上的数组和对象的拷贝。它的实现并不难，只要递归调用”浅拷贝”就行了。

    function deepCopy(p, c) {
        var c = c || {};
        for (var i in p) {
            if (typeof p[i] === 'object') {
                c[i] = (p[i].constructor === Array) ? [] : {};
                deepCopy(p[i], c[i]);
            } else {
                c[i] = p[i];
            }
        }
        return c;
    }

使用的时候这样写：

    var Doctor = deepCopy(Chinese);

现在，给父对象加一个属性，值为数组。然后，在子对象上修改这个属性：

    Chinese.birthPlaces = ['北京','上海','香港'];
    Doctor.birthPlaces.push('厦门');

这时，父对象就不会受到影响了。

    alert(Doctor.birthPlaces); //北京, 上海, 香港, 厦门
    alert(Chinese.birthPlaces); //北京, 上海, 香港

目前，jQuery库使用的就是这种继承方法。

本文转载自：阮一峰的网络日志

Javascript 面向对象编程（二）：构造函数继承

2016-10-20T00:00:00+08:00

之前已經介紹了如何”封装”数据和方法，以及如何从原型对象生成实例。

本文主要介紹：对象之间的”继承”的五种方法。

比如，现在有一个”动物”对象的构造函数。

    function Animal(){
        this.species = "动物";
    }

还有一个”猫”对象的构造函数。

    function Cat(name,color){
        this.name = name;
        this.color = color;
    }

怎样才能使”猫”继承”动物”呢？

一、构造函数绑定

第一种方法也是最简单的方法，使用call或apply方法，将父对象的构造函数绑定在子对象上，即在子对象构造函数中加一行：

    function Cat(name,color){
        Animal.apply(this, arguments);
        this.name = name;
        this.color = color;
    }
    var cat1 = new Cat("大毛","黄色");
    alert(cat1.species); // 动物

二、 prototype模式

第二种方法更常见，使用prototype属性。

如果”猫”的prototype对象，指向一个Animal的实例，那么所有”猫”的实例，就能继承Animal了。

    Cat.prototype = new Animal();
    Cat.prototype.constructor = Cat;
    var cat1 = new Cat("大毛","黄色");
    alert(cat1.species); // 动物

代码的第一行，我们将Cat的prototype对象指向一个Animal的实例。

    Cat.prototype = new Animal();

它相当于完全删除了prototype 对象原先的值，然后赋予一个新值。但是，第二行又是什么意思呢？

    Cat.prototype.constructor = Cat;

原来，任何一个prototype对象都有一个constructor属性，指向它的构造函数。如果没有”Cat.prototype = new Animal();”这一行，Cat.prototype.constructor是指向Cat的；加了这一行以后，Cat.prototype.constructor指向Animal。

    alert(Cat.prototype.constructor == Animal); //true

更重要的是，每一个实例也有一个constructor属性，默认调用prototype对象的constructor属性。

    alert(cat1.constructor == Cat.prototype.constructor); // true

因此，在运行”Cat.prototype = new Animal();”这一行之后，cat1.constructor也指向Animal。

    alert(cat1.constructor == Animal); // true

这显然会导致继承链的紊乱（cat1明明是用构造函数Cat生成的），因此我们必须手动纠正，将Cat.prototype对象的constructor值改为Cat。这就是第二行的意思。

这是很重要的一点，编程时务必要遵守。下文都遵循这一点，即如果替换了prototype对象，

    o.prototype = {};

那么，下一步必然是为新的prototype对象加上constructor属性，并将这个属性指回原来的构造函数。

    o.prototype.constructor = o;

三、直接继承prototype

第三种方法是对第二种方法的改进。由于Animal对象中，不变的属性都可以直接写入Animal.prototype。所以，我们也可以让Cat()跳过 Animal()，直接继承Animal.prototype。

现在，我们先将Animal对象改写：

    function Animal(){ }
    Animal.prototype.species = "动物";

然后，将Cat的prototype对象，然后指向Animal的prototype对象，这样就完成了继承。

    Cat.prototype = Animal.prototype;
    Cat.prototype.constructor = Cat;
    var cat1 = new Cat("大毛","黄色");
    alert(cat1.species); // 动物

与前一种方法相比，这样做的优点是效率比较高（不用执行和建立Animal的实例了），比较省内存。缺点是 Cat.prototype和Animal.prototype现在指向了同一个对象，那么任何对Cat.prototype的修改，都会反映到Animal.prototype。

所以，上面这一段代码其实是有问题的。请看第二行

    Cat.prototype.constructor = Cat;

这一句实际上把Animal.prototype对象的constructor属性也改掉了！

    alert(Animal.prototype.constructor); // Cat

四、利用空对象作为中介

由于”直接继承prototype”存在上述的缺点，所以就有第四种方法，利用一个空对象作为中介。

    var F = function(){};
    F.prototype = Animal.prototype;
    Cat.prototype = new F();
    Cat.prototype.constructor = Cat;

F是空对象，所以几乎不占内存。这时，修改Cat的prototype对象，就不会影响到Animal的prototype对象。

    alert(Animal.prototype.constructor); // Animal

我们将上面的方法，封装成一个函数，便于使用。

    function extend(Child, Parent) {
        var F = function(){};
        F.prototype = Parent.prototype;
        Child.prototype = new F();
        Child.prototype.constructor = Child;
        Child.uber = Parent.prototype;
    }

使用的时候，方法如下

    extend(Cat,Animal);
    var cat1 = new Cat("大毛","黄色");
    alert(cat1.species); // 动物

这个extend函数，就是YUI库如何实现继承的方法。

另外，说明一点，函数体最后一行

    Child.uber = Parent.prototype;

意思是为子对象设一个uber属性，这个属性直接指向父对象的prototype属性。（uber是一个德语词，意思是”向上”、”上一层”。）这等于在子对象上打开一条通道，可以直接调用父对象的方法。这一行放在这里，只是为了实现继承的完备性，纯属备用性质。

五、拷贝继承

上面是采用prototype对象，实现继承。我们也可以换一种思路，纯粹采用”拷贝”方法实现继承。简单说，如果把父对象的所有属性和方法，拷贝进子对象，不也能够实现继承吗？这样我们就有了第五种方法。

首先，还是把Animal的所有不变属性，都放到它的prototype对象上。

    function Animal(){}
    Animal.prototype.species = "动物";

然后，再写一个函数，实现属性拷贝的目的。

    function extend2(Child, Parent) {
        var p = Parent.prototype;
        var c = Child.prototype;
        for (var i in p) {
            c[i] = p[i];
        }
        c.uber = p;
    }

这个函数的作用，就是将父对象的prototype对象中的属性，一一拷贝给Child对象的prototype对象。

使用的时候，这样写：

    extend2(Cat, Animal);
    var cat1 = new Cat("大毛","黄色");
    alert(cat1.species); // 动物

本文转载自：阮一峰的网络日志

Javascript 面向对象编程（一）：封装

2016-10-20T00:00:00+08:00

Javascript是一种基于对象（object-based）的语言，你遇到的所有东西几乎都是对象。但是，它又不是一种真正的面向对象编程（OOP）语言，因为它的语法中没有class（类）。那么，如果我们要把”属性”（property）和”方法”（method），封装成一个对象，甚至要从原型对象生成一个实例对象，我们应该怎么做呢？

一，生成实例对象的原始模式

假定我们把猫看成一个对象，它有”名字”和”颜色”两个属性。

    var Cat = {
        name : '',
        color : ''
    }

现在，我们需要根据这个原型对象的规格（schema），生成两个实例对象。

    var cat1 = {}; // 创建一个空对象
        cat1.name = "大毛"; // 按照原型对象的属性赋值
        cat1.color = "黄色";

    var cat2 = {};
        cat2.name = "二毛";
        cat2.color = "黑色";

好了，这就是最简单的封装了，把两个属性封装在一个对象里面。但是，这样的写法有两个缺点，一是如果多生成几个实例，写起来就非常麻烦；二是实例与原型之间，没有任何办法，可以看出有什么联系。

二，原始模式的改进

我们可以写一个函数，解决代码重复的问题。

    function Cat(name,color) {
        return {
            name:name,
            color:color
        }
    }

然后生成实例对象，就等于是在调用函数：

    var cat1 = Cat("大毛","黄色");

    var cat2 = Cat("二毛","黑色");

这种方法的问题依然是，cat1和cat2之间没有内在的联系，不能反映出它们是同一个原型对象的实例。

三，构造函数模式

为了解决从原型对象生成实例的问题，Javascript提供了一个构造函数（Constructor）模式。

所谓”构造函数”，其实就是一个普通函数，但是内部使用了this变量。对构造函数使用new运算符，就能生成实例，并且this变量会绑定在实例对象上。

比如，猫的原型对象现在可以这样写，

    function Cat(name,color){
        this.name=name;
        this.color=color;
    }

我们现在就可以生成实例对象了。

    var cat1 = new Cat("大毛","黄色");

    var cat2 = new Cat("二毛","黑色");

    alert(cat1.name); // 大毛

    alert(cat1.color); // 黄色

这时cat1和cat2会自动含有一个constructor属性，指向它们的构造函数。

    alert(cat1.constructor == Cat); //true
    alert(cat2.constructor == Cat); //true

Javascript还提供了一个instanceof运算符，验证原型对象与实例对象之间的关系。

    alert(cat1 instanceof Cat); //true
    alert(cat2 instanceof Cat); //true

四，构造函数模式的问题

构造函数方法很好用，但是存在一个浪费内存的问题。

请看，我们现在为Cat对象添加一个不变的属性type（种类），再添加一个方法eat（吃）。那么，原型对象Cat就变成了下面这样：

    function Cat(name,color){
        this.name = name;
        this.color = color;
        this.type = "猫科动物";
        this.eat = function(){alert("吃老鼠");};
    }

还是采用同样的方法，生成实例：

    var cat1 = new Cat("大毛","黄色");
    var cat2 = new Cat ("二毛","黑色");
    alert(cat1.type); // 猫科动物
    cat1.eat(); // 吃老鼠

表面上好像没什么问题，但是实际上这样做，有一个很大的弊端。那就是对于每一个实例对象，type属性和eat()方法都是一模一样的内容，每一次生成一个实例，都必须为重复的内容，多占用一些内存。这样既不环保，也缺乏效率。

    alert(cat1.eat == cat2.eat); //false

能不能让type属性和eat()方法在内存中只生成一次，然后所有实例都指向那个内存地址呢？回答是可以的。

五、 Prototype模式

Javascript规定，每一个构造函数都有一个prototype属性，指向另一个对象。这个对象的所有属性和方法，都会被构造函数的实例继承。

这意味着，我们可以把那些不变的属性和方法，直接定义在prototype对象上。

    function Cat(name,color){
        this.name = name;
        this.color = color;
    }
    Cat.prototype.type = "猫科动物";
    Cat.prototype.eat = function(){alert("吃老鼠")};

然后，生成实例。

    var cat1 = new Cat("大毛","黄色");
    var cat2 = new Cat("二毛","黑色");
    alert(cat1.type); // 猫科动物
    cat1.eat(); // 吃老鼠

这时所有实例的type属性和eat()方法，其实都是同一个内存地址，指向prototype对象，因此就提高了运行效率。

    alert(cat1.eat == cat2.eat); //true

六、 Prototype模式的验证方法

为了配合prototype属性，Javascript定义了一些辅助方法，帮助我们使用它。，

6.1 isPrototypeOf()

这个方法用来判断，某个proptotype对象和某个实例之间的关系。

    alert(Cat.prototype.isPrototypeOf(cat1)); //true
    alert(Cat.prototype.isPrototypeOf(cat2)); //true

6.2 hasOwnProperty()

每个实例对象都有一个hasOwnProperty()方法，用来判断某一个属性到底是本地属性，还是继承自prototype对象的属性。

    alert(cat1.hasOwnProperty("name")); // true
    alert(cat1.hasOwnProperty("type")); // false

6.3 in运算符

in运算符可以用来判断，某个实例是否含有某个属性，不管是不是本地属性。

    alert("name" in cat1); // true
    alert("type" in cat1); // true

in运算符还可以用来遍历某个对象的所有属性。

    for(var prop in cat1) { alert("cat1["+prop+"]="+cat1[prop]); }

本文转载自：阮一峰的网络日志

javascript中的闭包

2016-10-19T00:00:00+08:00

导读

闭包是一个比较抽象的概念,尤其是对js新手来说.书上的解释实在是比较晦涩,对我来说也是一样。

但是他也是js能力提升中无法绕过的一环,几乎每次面试必问的问题,因为在回答的时候.你的答案的深度,对术语的理解以及js内部解释器的运作方式的描述,都是可以看出你js实际水平的.即使你没答对,也能让考官对你的水平有个评估.那么我先来说说我对js中的闭包的理解。

闭包是很多语言都具备的特性,在js中,闭包主要涉及到js的几个其他的特性:作用域链,垃圾(内存)回收机制,函数嵌套,等等。

在理解闭包以前.最好能先理解一下作用域链的含义,简单来说,作用域链就是函数在定义的时候创建的,用于寻找使用到的变量的值的一个索引,而他内部的规则是,把函数自身的本地变量放在最前面,把自身的父级函数中的变量放在其次,把再高一级函数中的变量放在更后面,以此类推直至全局对象为止.当函数中需要查询一个变量的值的时候,js解释器会去作用域链去查找,从最前面的本地变量中先找,如果没有找到对应的变量,则到下一级的链上找,一旦找到了变量,则不再继续.如果找到最后也没找到需要的变量,则解释器返回undefined。

了解了作用域链,我们再来看看js的内存回收机制,一般来说,一个函数在执行开始的时候,会给其中定义的变量划分内存空间保存,以备后面的语句所用,等到函数执行完毕返回了,这些变量就被认为是无用的了.对应的内存空间也就被回收了.下次再执行此函数的时候,所有的变量又回到最初的状态,重新赋值使用.但是如果这个函数内部又嵌套了另一个函数,而这个函数是有可能在外部被调用到的.并且这个内部函数又使用了外部函数的某些变量的话.这种内存回收机制就会出现问题.如果在外部函数返回后,又直接调用了内部函数,那么内部函数就无法读取到他所需要的外部函数中变量的值了.所以js解释器在遇到函数定义的时候,会自动把函数和他可能使用的变量(包括本地变量和父级和祖先级函数的变量(自由变量))一起保存起来.也就是构建一个闭包,这些变量将不会被内存回收器所回收,只有当内部的函数不可能被调用以后(例如被删除了,或者没有了指针),才会销毁这个闭包,而没有任何一个闭包引用的变量才会被下一次内存回收启动时所回收。

也就是说,有了闭包,嵌套的函数结构才可以运作,这也是符合我们的预期的.然后,闭包还有一些特性,却往往让程序员觉得很难理解。

探索

我们从内存结构上来讲解下 javascript中的闭包概念。

闭包：是指有权访问另外一个函数作用域中的变量的函数。创建闭包的常见方式就是在一个函数内部创建另外一个函数。

在javascript中没有块级作用域，一般为了给某个函数申明一些只有该函数才能使用的局部变量时，我们就会用到闭包，这样我们可以很大程度上减少全局作用域中的变量，净化全局作用域。

使用闭包有如上的好处，当然这样的好处是需要付出代价的，代价就是内存的占用。

如何理解上面的那句话呢？

每个函数的执行，都会创建一个与该函数相关的函数执行环境，或者说是函数执行上下文。这个执行上下文中有一个属性 scope chain（作用域链指针），这个指针指向一个作用域链结构，作用域链中的指针又都指向各个作用域对应的活动对象。正常情况，一个函数在调用开始执行时创建这个函数执行上下文及相应的作用域链，在函数执行结束后释放函数执行上下文及相应作用域链所占的空间。

比如：

    //声明函数
    function test(){
        var str = "hello world";
        console.log(str);
    }

    //调用函数
    test();

在调用函数的时候会在内存中生成如下图的结构：

但是闭包的情况就有点特殊了，由于闭包函数可以访问外层函数中的变量，所以外层函数在执行结束后，其作用域活动对象并不会被释放（注意，外层函数执行结束后执行环境和对应的作用域链就会被销毁），而是被闭包函数的作用域链所引用，直到闭包函数被销毁后，外层函数的作用域活动对象才会被销毁。这也正是闭包要占用内存的原因。

所以使用闭包有好处，也有坏处，滥用闭包会造成内存的大量消耗。

使用闭包还有其他的副作用，可以说是bug，也可以说不是，相对不同的业务可能就会有不同的看法。

这个副作用是闭包函数只能取到外层函数变量的最终值。

测试代码如下:(这里使用了jquery对象)

    /*闭包缺陷*/
    (function($){
        var result = new Array(),
        i = 0;
        for(;i<10;i++){
            result[i] = function(){
                return i;
            };
        }
        $.RES1 = result;
    })(jQuery);

    // 执行数组中的函数
    $.RES1[0]();

上面的代码先通过匿名函数表达式开辟了一块私有作用域，这个匿名函数就是我们上面所说的外层函数，该外层函数有一个参数$,同时还定义了变量result和 I , 通过for循环给数组result赋值一个匿名函数，这个匿名函数就是闭包，他访问了外层函数的变量I , 理论上数组resulti 会返回相应的数组下标值，实际情况却不如所愿。

如上代码 $.RES10 的执行结果是10.

为什么会这样呢，因为i的最终值就是10.

下面我们通过下图来详细说明下，上面的那段代码执行时在内存中到底发生了什么：

闭包的应用:保护函数内的变量安全。如前面的例子，函数outer中i只有函数inner才能访问，而无法通过其他途径访问到，因此保护了i的安全性。

在内存中维持一个变量。如前面的例子，由于闭包，函数outer中i的一直存在于内存中，因此每次执行rs()，都会给i加1。

那么这个副作用有没有办法可以修复呢？当然可以！

我们可以通过下面的代码来达到我们的预期。

    /*修复闭包缺陷*/
    (function($){
        var result = new Array(),
        i = 0;
        for(;i<10;i++){
            result[i] = (function(num){
                return function(){
                    return num;
                }
            })(i);
        }
        $.RES2 = result;
    })(jQuery);

    //调用闭包函数
    console.log($.RES2[0]());

上面的代码又在内存中发生了什么？我们同样用下面的一幅图来详细解释。看懂了上面的图，我们也就不难理解下面的图。

只要看懂上面的三张图，我们也就可以深入的理解清楚javascript中闭包的原理，以及闭包的好处和弊端，在我们的代码中合理的使用闭包，达到代码的整洁和高效。

php中的闭包

2016-10-19T00:00:00+08:00

在PHP中匿名函数（Anonymous functions），也叫闭包函数（ closures ），允许临时创建一个没有指定名称的函数。最经常用作回调函数（callback）的参数。当然，也有其他应用的情况。

注：php闭包是PHP5.3版本之后才有的

php闭包函数也可以作为变量的值来使用。PHP 会自动把此种表达式转换成内置类 Closure 的对象实例。把一个 closure 对象赋值给一个变量的方式与普通变量赋值的语法是一样的，最后也要加上分号;

疑问

如果你在理解闭包函数的时候觉得比较费解，不如放一放，问自己一个问题：面向对象编程语言对代码的复用主要采用继承来实现，那面向函数的代码复用能力通过什么来实现呢？

你可能第一时间想到的是函数嵌套，就是通过独立子函数来组织代码。那类似PHP里面的array_walk()、array_udiff()这些函数怎么实现呢？是不是觉得，有了匿名函数，array_walk()、array_udiff()这两个函数才可能得到这么好的复用？

所以按照最基础的理解来总结，我个人认为闭包函数的主要目的是为了函数复用而设计的，如果某个语言不支持闭包函数，那再函数复用的能力上就会差一些，但是通过类的面向接口来编程，也可以很好的复用代码的，所以一切根源都是为了代码复用。

之所以闭包函数这么难理解，我觉得是网上太多帖子根据闭包函数的能力做了很多各种各样的例子，譬如怎么不用写for循环，怎么动态给类添加函数，这些的确是闭包函数的能力之一，但是比不是闭包函数设计的根源，所以会误导读者，让读者更不了解闭包函数。更好的理解方式应该是逆过来，先了解为什么需要闭包函数，闭包函数是怎么工作的，然后在来理解闭包函数有哪些应用场景。

总的来理解，我以为，PHP里面闭包函数是为了复用函数而设计的语言特性，类似JavaScript等具有面向函数的编程语言一样，可以在闭包函数里面访问指定域的变量，在PHP里使用use关键字来实现。

Closure

PHP具有面向函数的编程特性，但是也是面向对象编程语言，PHP 会自动把闭包函数转换成内置类 Closure 的对象实例，依赖Closure 的对象实例又给闭包函数添加了更多的能力。例如Closure 的两个函数： Closure::bind —— 复制一个闭包，绑定指定的this对象和类作用域。Closure::bindTo —— 复制当前闭包对象，绑定指定的this对象和类作用域。

这两个函数的文字描述好让人费解，直白一点可以这样理解，通过这两个函数，可以指定闭包函数里 $this 变量的指向，和指明闭包函数的作用域。

具体底层怎么控制这个作用域就还没时间去看，不过知道作用域的概念就好。

闭包函数没有函数名称，直接在function()传入变量即可使用时将定义的变量当作函数来处理：

<?php
$greet = function($name)
{
    printf("Hello %s\r\n", $name);
};

$greet('World');//Hello World
$greet('PHP');//Hello PHP
?>

直接通过定义为匿名函数的变量名称来调用

<?php
echo preg_replace_callback('~-([a-z])~', function ($match) {
  return strtoupper($match[1]);
}, 'hello-world');
?>

闭包的语法很简单，需要注意的关键字就只有 use，闭包可以从父作用域中继承变量，任何此类变量都应该用 use 语言结构传递进去，use 是连接闭包和外界变量。这些变量都必须在函数或类的头部声明。从父作用域中继承变量与使用全局变量是不同的。全局变量存在于一个全局的范围，无论当前在执行的是哪个函数。而闭包的父作用域是定义该闭包的函数（不一定是调用它的函数）。

<?php
$message = 'a';

// 没有 "use"
$example = function () {
    var_dump($message);
};
echo $example(); //Notice: Undefined variable: message in F:\bak\PASYS\test.php on line 6 NULL

// 继承 $message
$example = function () use ($message) {
    var_dump($message);
};
echo $example();//string(1) "a"

// 闭包声明后，$message重新赋值，再调用上面定义好的匿名函数
$message = 'b';
echo $example(); //string(1) "a"

// $message重新赋值
$message = 'c';

// 重新声明闭包 继承并引用 $message
$example = function () use (&$message) {
    var_dump($message);
    $message = 'ccc';
};
echo $example();//string(5) "c"
var_dump($message);//string(3) "ccc"

// $message重新赋值
$message = 'd';
echo $example();//string(1) "d"
var_dump($message);//string(3) "ccc"

// 闭包函数和其他函数一样可以定义参数
$example = function ($arg) use ($message) {
    var_dump($arg . ' ' . $message);
};
$example("e");//string(1) "e ccc"
?>

http://www.cnblogs.com/yjf512/archive/2012/10/29/2744702.html

寂寞先生

Spring学习笔记：AOP

AOP的基本概念

Spring AOP

基于注解的AOP配置方式

1.启用@AsjectJ支持

2.通知类型介绍

3.例子：

4.通知执行的优先级

5.切入点的定义和表达式

6.基于XML形式的配置方式

Spring学习笔记：注解

常见注解

定义Bean的注解 【@Component/@Repository/@Service/@Controller】

1，xml配置

2，spring 上下文中注册bean

http请求注解（spring MVC模块注解）【@RequestMapping/@RequestParam/@PathVariable/@ResponseBody/@RequestBody】

@RequestMapping

1、 value， method；

2、consumes，produces

3、params，headers

@RequestParam 、@PathVariable 、@RequestBody 等

1、 @PathVariable

2、@RequestParam, @RequestBody

3，@RequestHeader、@CookieValue

4，@ResponseBody

自动装配Bean【@Primary/@Autowired/@Qualifier/@Resource】

1，@Primary和@Qualifier

2，@Autowired和@Resource

定义Bean的作用域和生命过程

singleton：单例模式

prototype:原型模式

request

session

声明式事务

php队列 —— rabbitmq

lumen中使用rabbitmq

1,安装rabbitMQ驱动库

2，注册rabbitMQ服务

3，配置

4，使用

linux(centos)系统安装lamp环境

准备工作：

1,编译安装环境需要gcc，make等编译工具,请确认安装了这些:

2,下载必要安装包，也可以使用wget命令直接下载：

3,安装依赖包

安装apache，mysql，php：

1，apache

2,mysql

1，解压并初始化

2，配置

拷贝配置文件，如果有就覆盖

3，php

1 安装

2，配置

1,系统配置

Apache主配置文件为

可能遇到的问题：

php编译

Javascript 面向对象编程：实例

Javascript 面向对象编程（三）：非构造函数的继承

一、什么是”非构造函数”的继承？

二、object()方法

三、浅拷贝

四、深拷贝

Javascript 面向对象编程（二）：构造函数继承

一、 构造函数绑定

二、 prototype模式

三、 直接继承prototype

四、 利用空对象作为中介

五、 拷贝继承

Javascript 面向对象编程（一）：封装

一，生成实例对象的原始模式

二，原始模式的改进

三，构造函数模式

四，构造函数模式的问题

六、 Prototype模式的验证方法

6.1 isPrototypeOf()

6.2 hasOwnProperty()

6.3 in运算符

定义Bean的注解【@Component/@Repository/@Service/@Controller】

一、构造函数绑定

三、直接继承prototype

四、利用空对象作为中介

五、拷贝继承

闭包函数没有函数名称，直接在function()传入变量即可使用时将定义的变量当作函数来处理：