风平浪静如码
风平浪静如码

程序员收藏不看系列：近三万字总结Spring注解开发！

注册组件

@Configuration

@Configuration等于一个配置文件，如果某个Java类上标注了这个注解，则表示这个类是一个配置类。

@Bean

将一个Java类装配到Spring的IOC容器中，默认是singleton。id默认是方法名。

@Data
@AllConstructorArgs
@ToString
public class Person(){
    private String name;
    private Integer age;
}
@Configuration
public class MainConfig{
    @Bean
    public Person persion(){
        return new Person("laowang",25);
    }
}
测试：
public class Test1{
    @Test
    public void test1(){
         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
         Person person = applicationContext.getBean(Person.class);
         System.out.println(person);
    }
}

@ComponentScan

在配置类上进行标注，指定Spring的扫描规则。

@Configuration
@ComponentScan(value="com.laowang.xxx")//使用某个包路径来指定Spring组件的扫描路径，如果想要装配的Bean不在这个指定的路径下，则不会被扫描。
public class MainConfig{
    @Bean
    public Person persion(){
        return new Person("laowang",25);
    }
}

excludeFilters排除

指定按照某些规则来排除组件。

使用TpyeFilter指定过滤规则

@Filter的FilterType

  • 「FilterType.ANNOTATION」 按注解排除
@Configuration
@ComponentScan(value="com.laowang.xxx",excludeFilters={
    @Filter(type=FilterType.ANNOTATION,
            classes={Controller.class})//排除Controller注解 
})
public class MainConfig{
    @Bean
    public Person persion(){
        return new Person("laowang",25);
    }
}
  • 「FilterType.ASPECTJ」 按AspectJ表达式排除
  • 「FilterType.ASSIGNABLE_TYPE」 按类排除
@Configuration
@ComponentScan(value="com.laowang.xxx",excludeFilters={
    @Filter(type=FilterType.ASSIGNABLE_TYPE,
            classes={Controller.class})//排除Controller注解 
})
public class MainConfig{
    @Bean
    public Person persion(){
        return new Person("laowang",25);
    }
}
  • 「FilterType.CUSTOM」 按自定义规则排除：需要创建一个类并实现TypeFilter接口
public class MyTypeFilter implememts TypeFilter{
    /**
    * metadataReader读取当前扫描类的信息
    * metadataReaderFactory可以获取他类的任何信息
    **/
    @Override
    public boolean match(MetadataReader metadataReader,MetadataReaderFactory metadataReaderFactory){
        //获取当前类的注解信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        //获取当前正在扫描的类的信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        //获取当前类的资源信息（类路径等）
        Resource resource = metadataReader.getResource();
        String className = classMetadata.getClassName();
        System.out.println("--->" + className);//返回类的全路径名
        if(className.contains("er")){//如果含有er，则装配
            return true;
        }
        return false;
        }
    }
}
@Configuration
@ComponentScan(value="com.laowang.xxx",excludeFilters={
    @Filter(type=FilterType.CUSTOM,
            classes={MyTypeFilter.class})//使用自定义规则的Filter
})
public class MainConfig{
    @Bean
    public Person persion(){
        return new Person("laowang",25);
    }
}
  • 「FilterType.REGEX」 按正则排除

includeFilters包含

与excludeFilters相反，指定需要哪些组件要被包含扫描。但是要配合userDefaultFilters=false配合使用,因为默认的扫描规则是扫描所有的，如果不配置，则会使用默认的规则进行扫描。

@Configuration
@ComponentScan(value="com.laowang.xxx",includeFilters={
    @Filter(type=FilterType.ANNOTATION,
            classes={Controller.class})},//包含Controller注解
            userDefaultFilters=false//禁用默认的扫描规则
)
public class MainConfig{
    @Bean
    public Person persion(){
        return new Person("laowang",25);
    }
}

@ComponentScans

在jdk8以后，@ComponentScan是个可重复注解@Repeatable。也可以使用@ComponentScans指定扫描策略

@ComponentScans({
    ComponentScan(value="com.laowang.xxx",includeFilters={
    @Filter(type=FilterType.ANNOTATION,
            classes={Controller.class})},
            userDefaultFilters=false)
})

@Scope

设置组件的作用域，如果是单例，则该Bean在装配的时候，Spring会自动创建并放到IOC容器中。如果是多实例，只会在使用到该Bean的时候才创建然后装配。

  • singleton 单例（默认）
@Scope
  • prototype 多实例
@Scope("prototype")
  • request 在web环境中，可以设置为request
  • session 在web环境中，可以设置为session

@Lazy-bean

针对singleton的实例，容器启动的时候先不创建，在第一次使用的时候创建，以后每次都从容器中去取。

@Conditional

按照条件注册Bean。

@Configuration
public class MainConfig{
    //如果是windows系统，则注册bill，如果是linux则注册linus
    @Condition({WindowsCondition.class})
    @Bean("bill")
    public Person person1(){
        return new Person("Bill",50);
    }
    @Condition({LinuxCondition.class})
    @Bean("linus")
    public Person person2(){
        return new Person("linus",48);
    }
}
public class LinuxCondition implements Condition{
    /**
    * context：判断条件能使用的上下文
    * annotatedTypeMetadata：注释信息
    **/
    @Override
    public boolean matches(ConditionContext context,AnnotatedTypeMetadata annotatedTypeMetadata){
        //判断是否是Linux系统
        //能获取到ioc使用的beanFactory
        ConfigurableListableBeanFactory factory = context.getBeanFactory();
        //获取类加载信息
        ClassLoader classLoader = context.getClassLoader();
        //获取当前信息环境
        Environment environment = context.getEnvironment();
        //获取到Bean定义的注册类
        BeanDefinitionRegistry registry = context.getRegistry();
        String property = environment.getProperty("os.name");
        if(property.contains("linux")){
            return true;
        }
        return false;
    }
}
public class WindowsCondition implements Condition{
     @Override
    public boolean matches(ConditionContext context,AnnotatedTypeMetadata annotatedTypeMetadata){
            //获取当前信息环境
            Environment environment = context.getEnvironment();
            String property = environment.getProperty("os.name");
            if(property.contains("windows 10")){
                return true;
            }
            return false;
        }
}
//  备注：可以在运行的时候加参数：-Dos.name=linux进行测试。

Condition接口

public interface Condition{
    boolean matches(CondtionContenxt ctxt,AnnotatedTypeMetadata metadata);
}

ConditionContext 接口

public interface ConditionContext{
    BeanDefinitionRegistry getRegistry();//返回BeanDefinitionRegistry检查bean定义
    ConfigurableListableBeanFactory getBeanFactory();//返回ConfigurableListableBeanFactory检查bean是否存在，甚至探查bean的属性
    Environment getEnvironment();//返回Environment检查环境变量是否存在以及它的值是什么
    ResourceLoader getResourceLoader();//返回ResourceLoader所加载的资源。
    ClassLoader getClassLoader();//返回ClassLoader加载并检查类是否存在。
}

AnnotatedTypeMetadata

能够让我们检查带有@Bean注解的方法上还有什么其他的注解。

@Import

快速给容器导入组件，组件名默认为全类名

public class Color{}
@Cofiguration
@Import({Color.class,xxx.class})
public class MainConfig{
  
}

ImportSelector

导入选择器，需要自定义类并实现这个接口。

public calss Green{}
public class Blue{}
public class MyImportSelector implements ImportSelector{
    //返回值就是要导入到组件中的类的全类名
    //annotationMetadata：当前标注@Import注解类的所有注解信息
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata){
    
        //方法不要返回null
        return new String[]{"xxx.xxx.Green","xxx.xxx.Blue"};
    }
}
@Cofiguration
@Import({Color.class,xxx.class,MyImportSelector.class})
public class MainConfig{
  
}

ImportBeanDefinitionRegistry

给容器中添加组件。

public class Rainbow{
  
}
public class MyImportBeanDefinitionRegistry implements ImportBeanDefinitionRegistry{
    //把所有需要添加到容器中的Bean，可以通过BeanDefinitionRegistry.registerBeanDefinition注册进来。
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata,BeanDefinitionRegistry registry){
        boolean definition = registry.containsBeanDefinition("xxx.xxx.Green");
        if(definition){
            RootBeanDefinition beanDefinition = new RootBeanDefinition(Rainbow.class);
            registry.registerBeanDefinition("rainbow",beanDefinition);
        }
    }
}
@Cofiguration
@Import({Color.class,xxx.class,MyImportSelector.class,MyImportBeanDefinitionRegistry.class})
public class MainConfig{
}

FactoryBean

工厂Bean，使用getObject()方法来注册Bean。

public class ColorFactoryBean implements FactoryBean{
    //返回的对象会添加到容器中
    @Override
    public Color getObject() throws Exception{
        return new Color();
    }
    //设置返回对象的类型
    @Override
    public Class getObjectType(){
        return Color.class;
    }
    //控制Bean是否是单例
    @Override
    public boolean isSingleton(){
        return false;
    }
}
@Cofiguration
public class MainConfig{
    @Bean 
    ColorFactoryBean colorFactoryBean(){
        return new ColorFactoryBean();
        //注意，IOC容器会将ColorFactoryBean和Color同时注册。但是使用applicationContext.getBean("ColorFactoryBean");打印的结果是xxx.xxx.Color。因为这个装配的Bean实际是装配了Color这个类，而不是ColorFactoryBean这个类。
        //而如果想要获取到这个ColorFactoryBean类的信息，则在获取Bean的时候加上&符号，即applicationContext.getBean("&ColorFactoryBean");打印的结果才是colorFactoryBean。
    }
}

生命周期

@Bean指定初始化和销毁方法

Bean的生命周期：创建---初始化---销毁的过程。可以自定义初始化和销毁方法。

  • 初始化：在对象完成，并赋值后，调用初始化方法。
  • 销毁：在容器关闭的时候销毁。
  • 单实例Bean会自动初始化和销毁，但是一旦该Bean被装配为多实例，在实际调用的时候才创建该Bean并且容器关闭的时候不会销毁该Bean，需要我们手动销毁。也就是说，在该Bean被装配为多实例后，容器只会帮忙创建而将不再管理该Bean。

指定init和detroy方法

public class Car {
    public Car(){
        System.out.println("car constructor....");
    }
    public void init(){
        System.out.println("car init....");
    }
    public void destory(){
        System.out.println("car destroy....");
    }
}
@Configuration
public class MainConfig{
    @Bean(initMethod="init",destroyMethod="destroy")
    public Car car(){
        return new Car();
    }
}
//  注意：如果想要看到Bean销毁的效果，需要手动调用applcationContext.close()方法。

InitializingBean和DisposableBean

@Compoent
public class Trunk implements InitializingBean,DisposableBean {
    public Trunk(){
        System.out.println("trunk constructor....");
    }
    @Override
    public void destory() throws Exception{
        System.out.println("trunk destory....");
    }
    @Override
    public void afterPropertiesSet() throws Exception{
        System.out.println("trunk afterPropertiesSet....");
    }
}

@PostConstruct和@PreDestroy

JSR250的规范。

@Component
public class Car {
    public Car(){
        System.out.println("car constructor....");
    }
    @PostConstruct
    public void init(){
        System.out.println("car init....");
    }
    @PreDestroy
    public void destory(){
        System.out.println("car destroy....");
    }
}

BeanPostProcessor接口

在Bean初始化前后做一些事情，具体需要实现postProcessorBeforeInitialization和postProcessorAfterInitialization方法。

public class MyBeanPostProcessor implements BeanPostProcessor{
    /**
    * 可以返回origin bean 也可以返回wrapper bean
    **/
    @Override
    public Object postProcessorBeforeInitialization(Object bean,String beanName) throws Exception{
        System.out.println("postProcessorBeforeInitialization...");
        return bean;
    }
    @Override
    public Object postProcessorAfterInitialization(Object bean,String beanName) throws Exception{
         System.out.println("postProcessorAfterInitialization...");
         return bean;
    }
}

属性赋值

@Value

  • 可以写基本值
  • 可以写SpEL表达式：#{}
  • 可以写${}取出配置文件的值

@PropertySource

指定配置文件。

@PropertySource(value={"classpath:/xxx.properties"})

自动装配

@Autowired&@Qualifier&@Primary

  • @Autowired默认按类型查找，如果找到多个相同类型的组件，再将属性名作为id查找。可以设置required=false，非必须。
  • @Autowired如果放到构造器上，则传入的对象是从容器中获取。如果只有一个有参的构造函数，@Autowired可以省略。
  • @Qualifier 明确指定要装配的组件id
  • @Primary Spring自动装配的时候默认使用首选的Bean。

@Resource&@Inject

  • JSR 250 @Resource，默认按名称进行装配。
  • JSR 330 @Inject，需要引入javax.inject包，与@Autowired功能一样。

@Profile

Spring提供的可以根据当前环境动态激活和切换一系列组件（Bean）的功能。指定组件在哪个环境下才能被注册到容器。不指定的话，任何环境都能注册。

放在组件上

参数：value表示条件，默认值是default，比如：

@Profile("test")
@Bean("testDB")
xxx
@Profile("dev")
@Bean("devDB")
xxx
@Profile("prod")
@Bean("prodDB")
xxx
  • 开发环境
  • 测试环境
  • 生产环境

放在类上

如果该注解放在类上，则这个类里面所有的组件都只有这个环境下才能会被注册。

使用

  • 可以在运行时增加参数：-Dspring.profiles.active=test来调用相应的环境。
  • 使用代码的方式
1. 创建一个ApplicationContext对象：
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
2. 设置需要激活的环境，可以设置多个。
applicationContext.getEnvironment().setActiveProfiles("test","dev");
3. 注册主配置类
applicationContext.register(MainConfig.class);
4. 启动刷新容器
applicationContext.refresh();

Aware接口

BeanNameAware

组件名解析器

ApplicationContextAware

可注入Spring容器上下文。

EmbeddedValueResolverAware

值解析器
等等，如下图所示：

xxxProcessor

用来处理各种Aware注入的问题，以ApplicationContextAwareProcessor为例，底层源码如下：

class ApplicationContextAwareProcessor implements BeanPostProcessor {
    private final ConfigurableApplicationContext applicationContext;
    private final StringValueResolver embeddedValueResolver;

    public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
        this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
    }
    //此处的作用是在Bean初始化之前做一些事情。
    @Nullable
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        AccessControlContext acc = null;
        //判断该Bean是否是实现了xxxAware接口。
        if (System.getSecurityManager() != null && (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware || bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware || bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }
        //判断是否有权限
        if (acc != null) {
            AccessController.doPrivileged(() -> {
                this.invokeAwareInterfaces(bean);
                return null;
            }, acc);
            //然后调用设置Aware的方法。
        } else {
            this.invokeAwareInterfaces(bean);
        }

        return bean;
    }
    //实际实现：判断具体是哪个Aware，最终将相应的Aware赋值给该bean的setXxxAware的方法。
    private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof EnvironmentAware) {
                ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
            }

            if (bean instanceof EmbeddedValueResolverAware) {
                ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
            }

            if (bean instanceof ResourceLoaderAware) {
                ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
            }

            if (bean instanceof ApplicationEventPublisherAware) {
                ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
            }

            if (bean instanceof MessageSourceAware) {
                ((MessageSourceAware)bean).setMessageSource(this.applicationContext);
            }

            if (bean instanceof ApplicationContextAware) {
                ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
            }
        }

    }
    //后置处理做一些事情。
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

AOP

概念

面向切面编程，需要增加功能的时候，不在源代码上进行修改，减少代码的耦合。使用面向切面的方式来对要执行的代码的前后逻辑进行控制。

  • @Before前置通知
  • @After后置通知
  • @AfterReturning返回通知
  • @AfterThrowing异常通知
  • @Around环绕通知：动态代理，手动推进方法执行(joinPoint.procceed())。例：
//注意，必须开启这个注解，表示启用注解版的切面功能。
@EnableAspectJAutoProxy
@Configuration
public class MainConfig{
    @Bean
    public Compute compute(){
        return new Compute();
    }
    @Bean
    public LogAspect logAspect(){
        return new logAspect();
    }
}
public class Compute {
    public int div(int i,int j){
        return i/j;
    }
}
//告诉Spring当前类是个切面类。
@Aspect
public class LogAspect{
    //也可以在此处创建一个方法，并且下面注解中的参数就填这个方法名。并且带上@PointCut。
    @PointCut("execution()")
    public void pointCut(){
    
    }
    @Before(切入表达式||"pointCut()")
    public void logStart(){
        System.out.println("logStart...");
    }
    @After(切入表达式)
    public void logEnd(){
        System.out.println("logEnd...");
    }
    //可以获取返回值
    @AfterReturning(value=切入表达式,returning="result")
    public void logReturn(Object result){
        System.out.println("logReturn..."); 
    }
    //可以获取异常信息
    @AfterThrowing(value=切入表达式, throwing="exception")
    public void logExeption(JoinPoint joinPoint,Exception exception){
        //可以通过这个参数获取方法的名称、参数等信息。
        //获取方法名
        joinPoint.getSignature().getName();
        //获取参数。
        joinPoint.getArgs();
        System.out.println("logExeption...");
    }
}
//  注意：JoinPoint一定要写在参数第一个。也就是：JoinPoint joinPoint,Exception exception。而不能写到后面：Exception exception,JoinPoint joinPoint，否则会报错。

切面表达式

Spring借助AspectJ的切点表达式来定义Spring切面。

execution表达式

execution (<修饰符模式>?<返回类型模式><方法名模式>(<参数模式>)<异常模式>?) 
execution (* com.sample.service.impl..*.*(..))
  • execution(): 表达式主体。
  • 第一个号：表示返回类型，号表示所有的类型。
  • 包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。
  • 第二个号：表示类名，号表示所有的类。
  • (..):最后这个星号表示方法名，号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。

通过方法签名定义切点

匹配所有目标类的public方法。第一个代表返回类型，第二个代表方法名，而..代表任意入参的方法：

execution(public * *(..))

匹配目标类所有以To为后缀的方法。第一个代表返回类型，而To代表任意以To为后缀的方法：

execution(* *To(..))

通过类定义切点

匹配Waiter接口的所有方法。第一个代表返回任意类型，com.baobaotao.Waiter.代表Waiter接口中的所有方法：

execution(* com.baobaotao.Waiter.*(..))

匹配Waiter接口及其所有实现类的方法：

execution(* com.baobaotao.Waiter+.*(..))

通过类包定义切点

在类名模式串中，"."表示包下的所有类，而".."表示包、子孙包下的所有类。　　匹配com.baobaotao包下所有类的所有方法：

execution(* com.baobaotao.*(..))

匹配com.baobaotao包、子孙包下所有类的所有方法，如com.baobaotao.dao，com.baobaotao.servier以及com.baobaotao.dao.user包下的所有类的所有方法都匹配。".."出现在类名中时，后面必须跟"*"，表示包、子孙包下的所有类：

execution(* com.baobaotao..*(..))

匹配包名前缀为com的任何包下类名后缀为Dao的方法，方法名必须以find为前缀。如com.baobaotao.UserDao#findByUserId()、com.baobaotao.dao.ForumDao#findById()的方法都匹配切点：

execution(* com..*.*Dao.find*(..))

通过方法入参定义切点

切点表达式中方法入参部分比较复杂，可以使用""和".."通配符，其中""表示任意类型的参数，而".."表示任意类型参数且参数个数不限。　　匹配joke(String,int)方法，且joke()方法的第一个入参是String，第二个入参是int。它匹配NaughtyWaiter#joke(String,int)方法。如果方法中的入参类型是Java.lang包下的类，可以直接使用类名，否则必须使用全限定类名，如joke(java.util.List,int)：

execution(* joke(String,int)))

匹配目标类中的joke()方法，该方法第一个入参为String，第二个入参可以是任意类型，如joke(Strings1,String s2)和joke(String s1,double d2)都匹配，但joke(String s1,double d2,String s3)则不匹配：

execution(* joke(String,*)))

匹配目标类中的joke()方法，该方法第 一个入参为String，后面可以有任意个入参且入参类型不限，如joke(String s1)、joke(String s1,String s2)和joke(String s1,double d2,String s3)都匹配:

execution(* joke(String,..)))

匹配目标类中的joke()方法，方法拥有一个入参，且入参是Object类型或该类的子类。它匹配joke(String s1)和joke(Client c)。如果我们定义的切点是execution(* joke(Object))，则只匹配joke(Object object)而不匹配joke(String cc)或joke(Client c)。

execution(* joke(Object+)))

args()和@args()

args()函数的入参是类名，@args()函数的入参必须是注解类的类名。虽然args()允许在类名后使用+通配符后缀，但该通配符在此处没有意义：添加和不添加效果都一样。

args()

该函数接受一个类名，表示目标类方法入参对象按类型匹配于指定类时，切点匹配，如下面的例子：

args(com.baobaotao.Waiter)

表示运行时入参是Waiter类型的方法，它和execution((com.baobaotao.Waiter))区别在于后者是针对类方法的签名而言的，而前者则针对运行时的入参类型而言。如args(com.baobaotao.Waiter)既匹配于addWaiter(Waiterwaiter)，也匹配于addNaiveWaiter(NaiveWaiter naiveWaiter)，而execution((com.baobaotao.Waiter))只匹配addWaiter(Waiterwaiter)方法；实际上，args(com.baobaotao.Waiter)等价于execution(**(com.baobaotao.Waiter+))，当然也等价于args(com.baobaotao.Waiter+)。

@args()

该函数接受一个注解类的类名，当方法的运行时入参对象标注发指定的注解时，方法匹配切点。

组合方式

execution(xxx) && within()
  • 可以使用&&或and表示且;||或or表示或；!或not表示非

获取通知方法的参数

@Aspect
public class TrackCounter {
    @Pointcut(value = "execution(* com.laowang.aop.TestBean.play(int)) && args(trackNumber)")
    public void trackPlay(int trackNumber) {
    }

    @Before(value = "trackPlay(trackNumber)")
    public void countTrackBefore(int trackNumber) {
        System.out.println("------before------");
        System.out.println("count :" + trackNumber++);
    }

    @After(value = "trackPlay(trackNumber)")
    public void getCount(int trackNumber) {
        System.out.println("------After------");
        System.out.println("count :" + trackNumber);
    }
}
--------------------------------------------------
/**
 * @author wangchao
 * @date 2020/10/26  13:58
 */
@Configuration
@EnableAspectJAutoProxy
public class ConfigurationTrack {
    @Bean
    public TestBean testBean() {
        return new TestBean();
    }

    @Bean
    public TrackCounter trackCounter() {
        return new TrackCounter();
    }
}
---------------------------------------------------
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ConfigurationTrack.class)
public class TestMain {
    @Autowired
    private TestBean testBean;
    @Autowired
    private TrackCounter trackCounter;

    @Test
    public void test1() {
        testBean.play(1);
        testBean.play(2);
        testBean.play(3);
        testBean.play(4);
    }
}

@DeclareParents

以透明的方式为被通知的对象引入额外的接口。

/**
 * @author wangchao
 * @date 2020/10/26  14:21
 * @desc aop用于扩展原始bean中的方法，可以扩展接口的实现类中的方法。
 */
public interface Encorable {
    void performanceEncore();
}

-------------------------------------------------
/**
 * @author wangchao
 * @date 2020/10/26  14:23
 */
public class DefaultEncorable implements Encorable {
    @Override
    public void performanceEncore() {
        System.out.println("test extract method!");
    }
}

----------------------------------------------
/**
 * @author wangchao
 * @date 2020/10/26  14:25
 */
@Aspect
public class EncorableIntroducer {
    @DeclareParents(value = "com.laowang.aop.Encorable+", defaultImpl = DefaultEncorable.class)
    public static Encorable encorable;
}

源码分析

@EnableAspectJAutoProxy

这个注解调用了@Import(AspectJAutoProxyRegistrar.class)：AspectJAutoProxyRegistrar可以给容器中导入自定义组件。实际上是注册了internalAutoProxyCreator这个组件。

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    AspectJAutoProxyRegistrar() {
    }
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //如果有需要就注册AspectJAnnotationAutoProxyCreator。
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }

            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }

    }
}
------------------------->
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
    //调用注册方法
    return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, (Object)null);
}

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
    //注册或升级AnnotationAwareAspectJAutoProxyCreator
    return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
-------------------------->
@Nullable
    private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        //判断是否已经有这个组件。
        if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
            BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
            if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
                int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                int requiredPriority = findPriorityForClass(cls);
                if (currentPriority < requiredPriority) {
                    apcDefinition.setBeanClassName(cls.getName());
                }
            }

            return null;
        } else {
            //否则就从RootBeanDefinition去注册一个AnnotationAwareAspectJAutoProxyCreator
            RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
            beanDefinition.setSource(source);
            beanDefinition.getPropertyValues().add("order", -2147483648);
            beanDefinition.setRole(2);
            //再注册internalAutoProxyCreator这个组件。
            registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
            return beanDefinition;
        }
    }

AnnotationAwareAspectJAutoProxyCreator

AnnotationAwareAspectJAutoProxyCreator
    -> AspectJAwareAdvisorAutoProxyCreator
        -> AbstractAdvisorAutoProxyCreator
            -> AbstractAutoProxyCreator implements SmartInstantiationAwareBeanPostProcessor,BeanFactoryAware
            后置处理器（在Bean初始化前后做一些事情）
  • AbstractAutoProxyCreator.setBeanFatory()方法。
  • AbstractAutoProxyCreator也有后置处理器的逻辑。
  • AbstractAdvisorAutoProxyCreator重写了setBeanFatory()方法，也就是说实际是调用了子类的setBeanFatory()方法。
  • AbstractAdvisorAutoProxyCreator.setBeanFatory() -> initBeanFactory();
  • AnnotationAwareAspectJAutoProxyCreator重写了initBeanFactory()方法。

分析容器启动加载这些组件的流程

  • 创建IOC容器：调用AnnotationConfigApplicationContext的有参构造函数。
//使用配置类的方式创建Spring容器
public AnnotationConfigApplicationContext(Class... annotatedClasses) {
    //无参的构造器创建对象
    this();
    //注册配置类
    this.register(annotatedClasses);
    //刷新容器
    this.refresh();
}
//使用包扫描路径的方式创建Spring容器。
public AnnotationConfigApplicationContext(String... basePackages) {
    //无参的构造器创建对象
    this();
    //扫描包
    this.scan(basePackages);
    //刷新容器
    this.refresh();
}
  • refresh()方法：刷新容器，创建所有的Bean及初始化信息。
public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                //注册Bean的后置处理器，拦截Bean的创建。
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }
  • registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory)方法，
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
    }

- 先获取IOC容器中已经定义了的需要创建对象的所有BeanPostProcessor。
- 给容器中添加其他的BeanPostProcessor。
- 判断是否是实现了PriorityOrdered的类，如果是，就表示该类有优先加载的权限。
- 再注册是否实现了Ordered接口的类。
- 最后注册普通优先级的类。

  • 从IOC容器中尝试获取BeanPostProcessor，如果没有，则创建。

  • populateBean：给Bean的各种属性赋值。

  • initializeBean：初始化Bean。

  • invokeAwareMethods：处理Aware接口的方法回调。

  • applyBeanPostProcessorBeforeInitialization()：应用后置处理器在初始化之前的操作。

  • invokeInitMethods()：执行初始化方法。

  • applyBeanPostProcessorAfterInitialization()：：应用后置处理器在初始化之后的操作。

  • BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功

aspectJAdvisorsBuilder
  • 把BeanPostProcessor注册到BeanFactory中
beanFactory.addBeanPostProcessor(postProcessor);

  • finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作

  • 创建剩下的单实例bean。

  • 后置处理器先尝试返回对象；bean = applyBeanPostProcessorsBeforeInstantiation（）：拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;就执行postProcessBeforeInstantiation。

  • BeanPostProcessor是在Bean对象创建完成初始化前后调用的

  • InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】

  • 遍历获取容器中所有的Bean：依次创建对象getBean(beanName)（getBean->doGetBean()->getSingleton()）

  • 创建bean：AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()。

  • 先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；只要创建好的Bean都会被缓存起来。

  • createBean（）;创建bean；AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例

  • resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation 希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续

if (bean != null) {
  bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
  • doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例。

AnnotationAwareAspectJAutoProxyCreator的作用

1、每一个bean创建之前，调用postProcessBeforeInstantiation()；

a.关心MathCalculator和LogAspect的创建
b.判断当前bean是否在advisedBeans中（保存了所有需要增强bean）
c.判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，或者是否是切面（@Aspect）
d.是否需要跳过。
e.获取候选的增强器（切面里面的通知方法）【ListcandidateAdvisors】每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true。
f.永远返回false

2、创建对象postProcessAfterInitialization；return wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下

a.JdkDynamicAopProxy(config);jdk动态代理；
b.ObjenesisCglibAopProxy(config);cglib的动态代理；
c.获取当前bean的所有增强器（通知方法） Object[] specificInterceptors
d.找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）
e.获取到能在bean使用的增强器。
f.给增强器排序
g.保存当前bean在advisedBeans中；
h.如果当前bean需要增强，创建当前bean的代理对象；
i.获取所有增强器（通知方法）
j.保存到proxyFactory
k.创建代理对象：Spring自动决定
l.给容器中返回当前组件使用cglib增强了的代理对象；
m.以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；

3、目标方法执行：容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存详细信息（比如增强器，目标对象，xxx）。

  • 如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法。
  • 链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行。
  • 拦截器链的机制，保证通知方法与目标方法的执行顺序。
  • 如果是MethodInterceptor，直接加入到集合中
  • 如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；转换完成返回MethodInterceptor数组；

a.CglibAopProxy.intercept();拦截目标方法的执行

b.根据ProxyFactory对象获取将要执行的目标方法拦截器链；List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

c.List interceptorList保存所有拦截器（5个，一个默认的ExposeInvocationInterceptor 和 4个增强器）

d.遍历所有的增强器，将其转为Interceptor（registry.getInterceptors(advisor)）。

e.将增强器转为List；

f.如果没有拦截器链，直接执行目标方法：拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）

g.如果有拦截器链，把需要执行的目标对象，目标方法，拦截器链等信息传入创建一个 CglibMethodInvocation 对象，并调用 Object retVal = mi.proceed();

h.拦截器链的触发过程;

如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法。
     
链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行。
      
拦截器链的机制，保证通知方法与目标方法的执行顺序。

总结

  • 1.@EnableAspectJAutoProxy 开启AOP功能

  • 2.@EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator

  • 3.AnnotationAwareAspectJAutoProxyCreator是一个后置处理器；

  • 4.容器的创建流程:

  • registerBeanPostProcessors（）注册后置处理器；创建AnnotatiAwareAspectJAutoProxyCreator对象

  • finishBeanFactoryInitialization（）初始化剩下的单实例bean

1. 创建业务逻辑组件和切面组件
   2. AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程
   3. 组件创建完之后，判断组件是否需要增强
      - 是：切面的通知方法，包装成增强器（Advisor）。
      - 否：给业务逻辑组件创建一个代理对象（cglib）。
   4. 执行目标方法：
      
      1. 代理对象执行目标方法
      2. CglibAopProxy.intercept()；
         - 得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）
         - 利用拦截器的链式机制，依次进入每一个拦截器进行执行；
         - 效果：
           - 正常执行：前置通知-》目标方法-》后置通知-》返回通知
           - 出现异常：前置通知-》目标方法-》后置通知-》异常通知

Servlet 3.0

简介

Servlet3.0提供了一些可插拔的注解，可以不适用配置文件的方式来玩转Servlet，Tomcat7以上版本才支持Servlet3.0。

@WebServlet

使用@WebServlet注解创建一个servlet并将该Servlet放到ServletContext容器中。

@WebServlet(value="/hello")
public class HelloServlet extends HttpServlet{
    @Override
    proteced void doGet(HttServletRequest req,HttpServletResponse res){
        res.getWriter().write("hello....");
    }
}

@WebFilter

类似@WebServlet，@WebFilter可以往ServletContext容器中注册一个Filter组件，继承Filter。

@WebFilter(“/foo”)
public class MyFilter implements Filter {
public void doFilter(HttpServletRequest req, HttpServletResponse
res)
    {
    ...
    }
}

@WebListener

@WebListener
public class MyListener implements ServletContextListener{
public void contextInitialized(ServletContextEvent sce) {
    ServletContext sc = sce.getServletContext();
    sc.addServlet("myServlet", "Sample servlet",
    "foo.bar.MyServlet", null, -1);
    sc.addServletMapping("myServlet", new String[] {
    "/urlpattern/*" });
    }
}

过滤规则

  • / 表示过滤所有请求，但是不会过滤.jsp，因为.jsp文件是交给tomcat的jsp引擎解析。
  • /* 表示过滤所有请求，包括*.jsp的请求。
  • /** 过滤多层所有请求。

Servlet3.0-ServletContainerListener

ServletContainerListener会在Servlet启动的时候会扫描所有jar文件中的META-INF/services/文件夹下的所有ServletContainerInitializer的实现文件，文件名为javax.servlet.ServletContainerInitializer，文件内容为ServletContainerInitializer的实现类的全类名。用来初始化注册自定义的组件(spi机制)。例：

1、在测试项目中的src目录下创建一个META-INF/services/javax.servlet.ServletContainerInitializer文件，并在里面写上自己的ServletContainerInitializer实现类的全路径。

//@HandlesTypes()这个注解可以将我们指定的类的子类或子接口注册进来，但是不包括扩这个类本身。
@HandlesTypes(value={})
public class MyServletContainerInitializer implements ServletContainerInitializer{
    //Set> arg0：注册我们感兴趣的类的所有子类。
    //ServletContext arg1：ServletContext容器，也可以通过这个参数手动注册组件（Servlet,Filter,Listener）。
    @Override
    public void onStartup(Set> arg0,ServletContext arg1){
        //注册Servlet组件,UserSerlvet为自定义的组件，需要实现HttpServlet接口。
        ServletRegistration.Dynamic servlet = arg1.addServlet("userSerlvet",new UserServlet());
        //添加Mapping，即匹配路径。
        servlet.addMapping("/user");
        //类似，注册Listener
        arg1.addListener(UserListener.class);
        //注册Filter，类似。
        FilterRegistration.Dynamic filter = arg1.addFilter("userFilter",UserFilter());
        filter.addMappingForUrlPatterns(EnumSet.of(DispatherType.REQUEST),true,"/**");
    }
}

Servlet3.0与SpringMVC整合分析

  1. web容器在启动的时候，会扫描每个jar包下的META-INF/services/javax.servlet.ServletContainerInitializer
  2. 加载这个文件指定的类SpringServletContainerInitializer
  3. spring的应用一启动会加载感兴趣的WebApplicationInitializer接口的下的所有组件；
  4. 并且为WebApplicationInitializer组件创建对象（组件不是接口，不是抽象类）

a.创建根容器：createRootApplicationContext() getRootConfigClasses();传入一个配置类。
b.创建web的ioc容器：createServletApplicationContext(); 获取配置类；getServletConfigClasses();
c.AbstractContextLoaderInitializer：创建根容器；createRootApplicationContext()；
d.AbstractDispatcherServletInitializer：创建一个web的ioc容器；createServletApplicationContext(); 创建了DispatcherServlet；createDispatcherServlet()；将创建的DispatcherServlet添加到ServletContext中；getServletMappings();
e.AbstractAnnotationConfigDispatcherServletInitializer：注解方式配置的DispatcherServlet初始化器：

总结：

以注解方式来启动SpringMVC，继承AbstractAnnotationConfigDispatcherServletInitializer，实现抽象方法指定DispatcherServlet的配置信息。

SpringMVC整合

/**
 * @author laowang
 * @Date 2019/3/18 14:48
 * @Description
 */
public class MyServletInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    //配置主容器
    @Override
    protected Class[] getRootConfigClasses() {
        return new Class[]{RootConfig.class};
    }

    //配置副容器
    @Override
    protected Class[] getServletConfigClasses() {
        return new Class[]{AppConfig.class};
    }

    //配置拦截规则
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

/**
 * @author laowang
 * @Date 2019/3/18 14:58
 * @Description
 */
//SpringMVC只扫描Controller，必须禁用默认的扫描规则。
@ComponentScan(value = "com.laowang.spring.servlet3",includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Controller.class)
},useDefaultFilters = false)
public class AppConfig {
}
/**
 * @author laowang
 * @Date 2019/3/18 14:58
 * @Description
 */
//Spring容器不扫描Controller
@ComponentScan(value = "com.laowang.spring.servlet3",excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
})
public class RootConfig {
}
/**
 * @author laowang
 * @Date 2019/3/18 15:03
 * @Description
 */
@Controller
public class HelloController {
    @Autowired
    private HelloService helloService;

    @ResponseBody
    @RequestMapping("/hello")
    public String hello() {
        return helloService.sayHello("laowang");
    }
}
/**
 * @author laowang
 * @Date 2019/3/18 15:04
 * @Description
 */
@Service
public class HelloService {

    public String sayHello(String name) {
        return "hello:" + name;
    }
}

SpringMVC定制

/**
 * @author laowang
 * @Date 2019/3/18 14:58
 * @Description
 */
//SpringMVC只扫描Controller，必须禁用默认的扫描规则。
@ComponentScan(value = "com.laowang.spring.servlet3",includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Controller.class)
},useDefaultFilters = false)
//开启WebMVC定制配置
@EnableWebMvc
public class AppConfig implements WebMvcConfigurer {
    //启用异步支持
    @Override
    public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
        configurer.registerCallableInterceptors();
    }
    //过滤静态资源
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
    //指定视图解析器，可以自定义
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.jsp("/WEB-INF/views/","jsp");
    }
    //配置拦截规则
    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
    }
    //配置自定义拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
    }
}

Servlet3.0异步请求

/**
 * @author laowang
 * @Date 2019/3/18 15:32
 * @Description
 */
//asyncSupported支持异步
@WebServlet(value = "/async", asyncSupported = true)
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //支持异步
        AsyncContext asyncContext = req.startAsync();
        System.out.println(Thread.currentThread() + "main thread start....." + System.currentTimeMillis());
        asyncContext.setTimeout(4000);
        asyncContext.start(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread() + "sub thread start....." + System.currentTimeMillis());
                    sayHello();
                    //告诉容器异步操作执行完毕，可以进行线程回收。
                    asyncContext.complete();
                    System.out.println(Thread.currentThread() + "sub thread end....." + System.currentTimeMillis());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        //使用asyncContext获取response并写出数据。
        asyncContext.getResponse().getWriter().write("async------------->");
        System.out.println(Thread.currentThread() + "main thread end....." + System.currentTimeMillis());
    }

    public void sayHello() throws Exception {
        Thread.sleep(3000);
        System.out.println("hello~");
    }
}

执行效果

Thread[http-bio-8080-exec-5,5,main]main thread start.....1552894856004
Thread[http-bio-8080-exec-5,5,main]main thread end.....1552894856006
Thread[http-bio-8080-exec-2,5,main]sub thread start.....1552894856006
hello~
Thread[http-bio-8080-exec-2,5,main]sub thread end.....1552894859007

SpringMVC异步请求

返回Callbale

/**
 * @author laowang
 * @Date 2019/3/18 15:42
 * @Description
 */
@Controller
public class AsyncController {
    @ResponseBody
    @RequestMapping("/async1")
    public Callable async1() {
        System.out.println(Thread.currentThread() + "main thread start....." + System.currentTimeMillis());
        Callable callable = new Callable() {
            @Override
            public String call() throws Exception {
                System.out.println(Thread.currentThread() + "sub thread start....." + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println(Thread.currentThread() + "sub thread end....." + System.currentTimeMillis());
                return "async1";
            }
        };
        System.out.println(Thread.currentThread() + "main thread end....." + System.currentTimeMillis());
        return callable;
    }
}

执行效果

preHandle...........
Thread[http-bio-8080-exec-10,5,main]main thread start.....1552895185639
Thread[http-bio-8080-exec-10,5,main]main thread end.....1552895185640
Thread[MvcAsync1,5,main]sub thread start.....1552895185646
Thread[MvcAsync1,5,main]sub thread end.....1552895187648
preHandle...........
postHandler...........

原理

  1. 控制器返回Callable
  2. Spring异步处理，将Callable 提交到 TaskExecutor 使用一个隔离的线程进行执行
  3. DispatcherServlet和所有的Filter退出web容器的线程，但是response 保持打开状态；
  4. Callable返回结果，SpringMVC将请求重新派发给容器，恢复之前的处理；
  5. 根据Callable返回的结果。SpringMVC继续进行视图渲染流程等（从收请求-视图渲染）。
preHandle.../springmvc-annotation/async1
主线程开始...Thread[http-bio-8081-exec-3,5,main]==>1513932494700
主线程结束...Thread[http-bio-8081-exec-3,5,main]==>1513932494700
=========DispatcherServlet及所有的Filter退出线程============================

================等待Callable执行==========
副线程开始...Thread[MvcAsync1,5,main]==>1513932494707
副线程开始...Thread[MvcAsync1,5,main]==>1513932496708
================Callable执行完成==========

================再次收到之前重发过来的请求========
preHandle.../springmvc-annotation/async1
postHandle...（Callable的之前的返回值就是目标方法的返回值）
afterCompletion...

返回DefferedResult

/**
 * @author laowang
 * @Date 2019/3/18 15:51
 * @Description
 */
//中间件，用来保存队列
public class DeferedQueue {
    private static Queue> defferedQueue = new ConcurrentLinkedDeque>();

    public static void save(DeferredResult object) {
        defferedQueue.add(object);
    }

    public static DeferredResult get() {
        return defferedQueue.poll();
    }
}
@Controller
public class DeferedResultController{
    @ResponseBody
    @RequestMapping("/create-order")
    public DeferredResult createOrder() {
        DeferredResult deferredResult = new DeferredResult<>();
        DeferedQueue.save(deferredResult);
        return deferredResult;
    }

    @ResponseBody
    @RequestMapping("/create")
    public String create() {
        String order = UUID.randomUUID().toString();
        DeferredResult deferedResult = DeferedQueue.get();
        deferedResult.setResult(order);
        return order;
    }
}
 
 
写在最后
 
 
欢迎大家关注我的公众号【风平浪静如码】，海量Java相关文章，学习资料都会在里面更新，整理的资料也会放在里面。
 
 
觉得写的还不错的就点个赞，加个关注呗！点关注，不迷路，持续更新！！！
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(程序员收藏不看系列：近三万字总结Spring注解开发！)

        

            

                
    
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • 《策划经理回忆录之二》
                        路基雅虎

                        
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 三大师传
                        beca酱

                        
    巴尔扎克的作品被誉为“法国社会的一面镜子”。文学大师维克多·雨果对巴尔扎克的评价是：“在最伟大的人物中间，巴尔扎克是名列前茅者；在最优秀的人物中间，巴尔扎克是佼佼者之一。”一个原本寂寂无名的小人物，从地中海的某个海岛上，只身一人来到巴黎，没有朋友，也没有名望。作为一个一文不名的外乡人，凭着赤手空拳赢得了巴黎，征服了整个法兰西，并且赢得了世界。这个人就是十九世纪法国伟大的军事家、政治家，法兰西第一帝
    
                    
    • 
                    
  • 开心
                        蒋泳频

                        
    从无比抗拒来上课到接受，感动，收获～看着波哥成长，晶晶幸福笑容满面。感觉自己做的事情很有意义，很开心！还有3个感召目标就是还有三个有缘人，哈哈。明天感召去明日计划：8：30-11：00小公益11：00-21点上班，感召图片发自App图片发自App图片发自App
    
                    
    • 
                    
  • 水平垂直居中的几种方法（总结）
                        LJ小番茄
CSS_玄学语言htmljavascript前端csscss3
                        
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • linux sdl windows.h,Windows下的SDL安装
                        奔跑吧linux内核
linuxsdlwindows.h
                        
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
    
                    
    • 
                    
  • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    
                    
    • 
                    
  • 谁家酒器最绝唱，藏在酒厂人未知？景阳冈酒厂先秦藏品大揭秘
                        李虓酒评论

                        
    文/王赛时中国的酒器酒具历史久远，举世闻名。从北京的故宫博物院、中国国家博物馆，到世界各国的大型博物馆，都以能够收藏中国古代酒具而夸耀。但很少有人知道，在山东阳谷景阳冈酒厂，默默地收藏了两千件中国酒器。这些酒器，就封藏在景阳冈的酒道馆里。其中有一些青铜酒器，一睡就是三、四千年，堪称无声国宝，堪作无字史书！今天，我将引领诸位首先窥视一下景阳冈酒道馆的9件先秦藏品，你自己来说震撼不震撼。提示：这只是景
    
                    
    • 
                    
  • PHP环境搭建详细教程
                        好看资源平台
前端php
                        
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
    
                    
    • 
                    
  • 我的黑历史
                        袖手围观有来有去

                        
    孩子同学与我们一起共进晚餐，俩孩子加我三个人。小同学是一个大方率性礼貌的小孩，我们也都非常喜欢。好了，回到正题上来让我把这个故事讲完。俩孩子都喜欢吃鱼，所以就发生了小孩子之间常会发生的事。我狠狠的盯了我家孩子，孩子表情有些狼狈。和孩子单独一起的时候，见她尚未释怀，并谴责我不该狠盯她，让她没面子。也许是她触动了我的童年往事吧。由此，一狠心，给她讲了一段埋藏心里极深的黑历史：我奶奶有四个儿子，四个儿子
    
                    
    • 
                    
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
    
                    
    • 
                    
  • 关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验java数据库开发语言
                        
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    
                    
    • 
                    
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记
                        爱吃丸子的小樱桃

                        
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
    
                    
    • 
                    
  • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    
                    
    • 
                    
  • 如果做到轻松在股市赚钱？只要坚持这三个原则。
                        履霜之人

                        
    大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
    
                    
    • 
                    
  • 《人世间》
                        南询yi

                        
    今日分享十点推文，《人世间》有感苏格拉底说：“天地只有三尺，而人在五尺开外，所以人人都要懂得低头。”深以为然。懂得低头，不是认输。而是于人世间找寻温存的成熟，于困境中寻觅柳暗花明的智慧，于争执中展示屈伸自如的格局。正如仰头不是骄傲，是要看见自己的天空；低头也不是认输，而是要看清自己的路。成大事者，不仅要抬头挺胸，还得低头看路。懂得低头，进退有度，不是认输，而是竭尽全力过好这一生。宫崎骏说过：“所有
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 运城寻访重逢石头纪实【严建设老照片395 集】 我简直能把你想透， 当我走进运城的时候。 我已急得热汗直流， 访问了十九个老头， 把晋南的小城转了三周。 虽然是悠久的思旧， 我仍然是牛样的执...
                        严建设

                        
    运城寻访重逢石头纪实【严建设老照片395集】我简直能把你想透，当我走进运城的时候。我已急得热汗直流，访问了十九个老头，把晋南的小城转了三周。虽然是悠久的思旧，我仍然是牛样的执拗。说什么变换的世情，泛起了过去的逝流，你就是真正的故友。踏破铁鞋的淡愁，已化为不废功夫的范畴，是就像远在天涯近在咫尺，就像是梦乡的邂逅，我紧紧地攥着你的手。你已长成了高高的个头，俊逸的容颜却很清瘦，你那样顽皮的童音，已变到老
    
                    
    • 
                    
  • 【加密社】Solidity 中的事件机制及其应用
                        加密社
闲侃区块链智能合约区块链
                        
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
    
                    
    • 
                    
  • 使用Faiss进行高效相似度搜索
                        llzwxh888
faisspython
                        
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
    
                    
    • 
                    
  • 利用Requests Toolkit轻松完成HTTP请求
                        nseejrukjhad
http网络协议网络python
                        
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
    
                    
    • 
                    
  • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    
                    
    • 
                                
  • log4j对象改变日志级别
                                    3213213333332132
javalog4jlevellog4j对象名称日志级别
                                    
    log4j对象改变日志级别可批量的改变所有级别，或是根据条件改变日志级别。 
 
log4j配置文件： 
 
 

log4j.rootLogger=ERROR,FILE,CONSOLE,EXECPTION
 
#log4j.appender.FILE=org.apache.log4j.RollingFileAppender
log4j.appender.FILE=org.apache.l
    
                                
    • 
                                
  • elk+redis 搭建nginx日志分析平台
                                    ronin47
elasticsearchkibanalogstash
                                    
                  elk+redis 搭建nginx日志分析平台 
logstash,elasticsearch,kibana 怎么进行nginx的日志分析呢？首先，架构方面，nginx是有日志文件的，它的每个请求的状态等都有日志文件进行记录。其次，需要有个队 列，redis的l
    
                                
    • 
                                
  • Yii2设置时区
                                    dcj3sjt126com
PHPtimezoneyii2
                                    
    时区这东西，在开发的时候，你说重要吧，也还好，毕竟没它也能正常运行，你说不重要吧，那就纠结了。特别是linux系统，都TMD差上几小时，你能不痛苦吗？win还好一点。有一些常规方法，是大家目前都在采用的1、php.ini中的设置，这个就不谈了，2、程序中公用文件里设置，date_default_timezone_set一下时区3、或者。。。自己写时间处理函数，在遇到时间的时候，用这个函数处理（比较
    
                                
    • 
                                
  • js实现前台动态添加文本框，后台获取文本框内容
                                    171815164
文本框
                                    
    

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://w
    
                                
    • 
                                
  • 持续集成工具
                                    g21121
持续集成
                                    
            持续集成是什么？我们为什么需要持续集成？持续集成带来的好处是什么？什么样的项目需要持续集成？...        持续集成(Continuous integration ,简称CI)，所谓集成可以理解为将互相依赖的工程或模块合并成一个能单独运行
    
                                
    • 
                                
  • 数据结构哈希表(hash)总结
                                    永夜-极光
数据结构
                                    
    1.什么是hash 
来源于百度百科: 
Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。 
  

    
                                
    • 
                                
  • 乱七八糟
                                    程序员是怎么炼成的

                                    
    eclipse中的jvm字节码查看插件地址： 
http://andrei.gmxhome.de/eclipse/ 
安装该地址的outline 插件  后重启，打开window下的view下的bytecode视图 
http://andrei.gmxhome.de/eclipse/ 
  
jvm博客： 
http://yunshen0909.iteye.com/blog/2
    
                                
    • 
                                
  • 职场人伤害了“上司” 怎样弥补
                                    aijuans
职场
                                    
     由于工作中的失误，或者平时不注意自己的言行“伤害”、“得罪”了自己的上司，怎么办呢？ 
　　在职业生涯中这种问题尽量不要发生。下面提供了一些解决问题的建议： 
　　一、利用一些轻松的场合表示对他的尊重 
　　即使是开明的上司也很注重自己的权威，都希望得到下属的尊重，所以当你与上司冲突后，最好让不愉快成为过去，你不妨在一些轻松的场合，比如会餐、联谊活动等，向上司问个好，敬下酒，表示你对对方的尊重，
    
                                
    • 
                                
  • 深入浅出url编码
                                    antonyup_2006
应用服务器浏览器servletweblogicIE
                                    
    出处：http://blog.csdn.net/yzhz  杨争   
http://blog.csdn.net/yzhz/archive/2007/07/03/1676796.aspx 
 
一、问题： 
        编码问题是JAVA初学者在web开发过程中经常会遇到问题，网上也有大量相关的
    
                                
    • 
                                
  • 建表后创建表的约束关系和增加表的字段
                                    百合不是茶
标的约束关系增加表的字段
                                    
      
下面所有的操作都是在表建立后操作的,主要目的就是熟悉sql的约束,约束语句的万能公式 
  
1,增加字段(student表中增加 姓名字段) 
  
alter table 增加字段的表名 add  增加的字段名   增加字段的数据类型

  alter table student add name varchar2(10);
 
  
&nb
    
                                
    • 
                                
  • Uploadify 3.2 参数属性、事件、方法函数详解
                                    bijian1013
JavaScriptuploadify
                                    
    一.属性     
属性名称   
默认值   
说明     
auto   
true   
设置为true当选择文件后就直接上传了，为false需要点击上传按钮才上传。     
buttonClass   
”   
按钮样式     
buttonCursor   
‘hand’   
鼠标指针悬停在按钮上的样子     
buttonImage   
null   
浏览按钮的图片的路
    
                                
    • 
                                
  • 精通Oracle10编程SQL(16)使用LOB对象
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *使用LOB对象
 */
--LOB(Large Object)是专门用于处理大对象的一种数据类型，其所存放的数据长度可以达到4G字节
--CLOB/NCLOB用于存储大批量字符数据，BLOB用于存储大批量二进制数据，而BFILE则存储着指向OS文件的指针

/*
 *综合实例
 */
--建立表空间 
--#指定区尺寸为128k,如不指定，区尺寸默认为64k 
CR
    
                                
    • 
                                
  • 【Resin一】Resin服务器部署web应用
                                    bit1129
resin
                                    
    工作中，在Resin服务器上部署web应用，通常有如下三种方式： 
  
 
 配置多个web-app 
 配置多个http id 
 为每个应用配置一个propeties、xml以及sh脚本文件 
 配置多个web-app 
  
 
 在resin.xml中,可以为一个host配置多个web-app 
 
  
<cluster id="app&q
    
                                
    • 
                                
  • red5简介及基础知识
                                    白糖_
基础
                                    
      
 
 简介 
 
  
Red5的主要功能和Macromedia公司的FMS类似，提供基于Flash的流媒体服务的一款基于Java的开源流媒体服务器。它由Java语言编写，使用RTMP作为流媒体传输协议，这与FMS完全兼容。它具有流化FLV、MP3文件，实时录制客户端流为FLV文件，共享对象，实时视频播放、Remoting等功能。用Red5替换FMS后,客户端不用更改可正
    
                                
    • 
                                
  • angular.fromJson
                                    boyitech
AngularJSAngularJS 官方APIAngularJS API
                                    
    angular.fromJson   描述:   把Json字符串转为对象    使用方法:   angular.fromJson(json);   参数详解:      Param Type Details   json 
string  
JSON 字符串      返回值:   对象, 数组, 字符串 或者是一个数字   示例:   
<!DOCTYPE HTML>
<h
    
                                
    • 
                                
  • java-颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I
                                    bylijinnan
java
                                    
    

public class ReverseWords {

	/**
	 * 题目：颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I.词以空格分隔。
	 * 要求：
	 * 1.实现速度最快,移动最少
	 * 2.不能使用String的方法如split,indexOf等等。
	 * 解答：两次翻转。
	 */
	publ
    
                                
    • 
                                
  • web实时通讯
                                    Chen.H
Web浏览器socket脚本
                                    
    关于web实时通讯，做一些监控软件。 
由web服务器组件从消息服务器订阅实时数据，并建立消息服务器到所述web服务器之间的连接，web浏览器利用从所述web服务器下载到web页面的客户端代理与web服务器组件之间的socket连接，建立web浏览器与web服务器之间的持久连接；利用所述客户端代理与web浏览器页面之间的信息交互实现页面本地更新，建立一条从消息服务器到web浏览器页面之间的消息通路
    
                                
    • 
                                
  • [基因与生物]远古生物的基因可以嫁接到现代生物基因组中吗?
                                    comsci
生物
                                    
     
 
      大家仅仅把我说的事情当作一个IT行业的笑话来听吧..没有其它更多的意思 
 
 
    如果我们把大自然看成是一位伟大的程序员,专门为地球上的生态系统编制基因代码,并创造出各种不同的生物来,那么6500万年前的程序员开发的代码,是否兼容现代派的程序员的代码和架构呢? 
 
  
    
                                
    • 
                                
  • oracle 外部表
                                    daizj
oracle外部表external tables
                                    
        oracle外部表是只允许只读访问，不能进行DML操作，不能创建索引，可以对外部表进行的查询，连接，排序，创建视图和创建同义词操作。 
you can select, join, or sort external table data. You can also create views and synonyms for external tables. Ho
    
                                
    • 
                                
  • aop相关的概念及配置
                                    daysinsun
AOP
                                    
    切面(Aspect): 
通常在目标方法执行前后需要执行的方法（如事务、日志、权限），这些方法我们封装到一个类里面，这个类就叫切面。 
 
 
连接点（joinpoint） 
spring里面的连接点指需要切入的方法，通常这个joinpoint可以作为一个参数传入到切面的方法里面（非常有用的一个东西）。 
 
 
通知（Advice） 
通知就是切面里面方法的具体实现，分为前置、后置、最终、异常环
    
                                
    • 
                                
  • 初一上学期难记忆单词背诵第二课
                                    dcj3sjt126com
englishword
                                    
    middle 中间的，中级的 
well 喔，那么；好吧 
phone 电话，电话机 
policeman 警察 
ask 问 
take 拿到；带到 
address 地址 
glad 高兴的，乐意的 
why 为什么  
China 中国 
family 家庭 
grandmother (外)祖母 
grandfather (外)祖父 
wife 妻子 
husband 丈夫 
da
    
                                
    • 
                                
  • Linux日志分析常用命令
                                    dcj3sjt126com
linuxlog
                                    
    1.查看文件内容 
cat 
-n 显示行号 2.分页显示 
more 
Enter 显示下一行 
空格 显示下一页 
F 显示下一屏 
B 显示上一屏 
less 
/get 查询"get"字符串并高亮显示 3.显示文件尾 
tail 
-f 不退出持续显示 
-n 显示文件最后n行 4.显示头文件 
head 
-n 显示文件开始n行 5.内容排序 
sort 
-n 按照
    
                                
    • 
                                
  • JSONP 原理分析
                                    fantasy2005
JavaScriptjsonpjsonp 跨域
                                    
    转自 http://www.nowamagic.net/librarys/veda/detail/224 
JavaScript是一种在Web开发中经常使用的前端动态脚本技术。在JavaScript中，有一个很重要的安全性限制，被称为“Same-Origin Policy”（同源策略）。这一策略对于JavaScript代码能够访问的页面内容做了很重要的限制，即JavaScript只能访问与包含它的
    
                                
    • 
                                
  • 使用connect by进行级联查询
                                    234390216
oracle查询父子Connect by级联
                                    
    使用connect by进行级联查询 
  
       connect by可以用于级联查询，常用于对具有树状结构的记录查询某一节点的所有子孙节点或所有祖辈节点。 
  
       来看一个示例，现假设我们拥有一个菜单表t_menu，其中只有三个字段：
    
                                
    • 
                                
  • 一个不错的能将HTML表格导出为excel,pdf等的jquery插件
                                    jackyrong
jquery插件
                                    
    发现一个老外写的不错的jquery插件，可以实现将HTML 
表格导出为excel,pdf等格式， 
地址在： 
https://github.com/kayalshri/ 
 
下面看个例子，实现导出表格到excel,pdf 
 
 


<html>
			<head>
				<title>Export html table to excel an
    
                                
    • 
                                
  • UI设计中我们为什么需要设计动效
                                    lampcy
UIUI设计
                                    
    关于Unity3D中的Shader的知识 
首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，
    
                                
    • 
                                
  • 如何禁止页面缓存
                                    nannan408
htmljspcache
                                    
    禁止页面使用缓存~ 
------------------------------------------------ 
jsp:页面no cache： 
 
response.setHeader("Pragma","No-cache"); 
response.setHeader("Cache-Control","no-cach
    
                                
    • 
                                
  • 以代码的方式管理quartz定时任务的暂停、重启、删除、添加等
                                    Everyday都不同
定时任务管理spring-quartz
                                    
          【前言】在项目的管理功能中，对定时任务的管理有时会很常见。因为我们不能指望只在配置文件中配置好定时任务就行了，因为如果要控制定时任务的 “暂停” 呢？暂停之后又要在某个时间点 “重启” 该定时任务呢？或者说直接 “删除” 该定时任务呢？要改变某定时任务的触发时间呢？ “添加” 一个定时任务对于系统的使用者而言，是不太现实的，因为一个定时任务的处理逻辑他是不
    
                                
    • 
                                
  • EXT实例
                                    tntxia
ext
                                    
      
（1） 增加一个按钮 
  
JSP: 
  
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
Stri
    
                                
    • 
                                
  • 数学学习在计算机研究领域的作用和重要性
                                    xjnine
Math
                                    
    最近一直有师弟师妹和朋友问我数学和研究的关系，研一要去学什么数学课。毕竟在清华，衡量一个研究生最重要的指标之一就是paper,而没有数学，是肯定上不了世界顶级的期刊和会议的，这在计算机学界尤其重要！你会发现，不论哪个领域有价值的东西，都一定离不开数学！在这样一个信息时代，当google已经让世界没有秘密的时候，一种卓越的数学思维，绝对可以成为你的核心竞争力.  无奈本人实在见地
    
                                
    •