import com.datastax.driver.mapping.annotations.Accessor; //导入依赖的package包/类
/**
 * Kicks off DAL generation.
 * @param tables the cassandra table meta data
 * @throws IOException if write to file fails
 */
public static void generate(Collection<TableMetadata> tables) throws IOException {
    String namespaceToUse = MetaData.instance.getDalNamespace();

    for (TableMetadata table : tables) {
        String rawName = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, table.getName());
        String name = rawName + "Accessor";

        ClassName entityTable = ClassName.get(MetaData.instance.getTableNamespace(), rawName);

        TypeSpec.Builder accessorBuilder = TypeSpec.interfaceBuilder(name)
                .addModifiers(Modifier.PUBLIC);

        accessorBuilder.addAnnotation(Accessor.class);

        List<ColumnMetadata> pKeyColumns = table.getPrimaryKey();
        List<ColumnMetadata> partitionKeyColumns = table.getPartitionKey();

        int partitionKeys = partitionKeyColumns.size();
        // if there is only 1 key or there's just the partition key without clustering keys
        if (isSingleValueKeyedTable(table)) {
            accessorBuilder.addMethod(generateAll(table, entityTable));
        } else {
            // if there are clustering keys after the partition key we need to start at the partition key
            int count = partitionKeys > 1 ? partitionKeys : 1;
            while (count < pKeyColumns.size()) {
                accessorBuilder.addMethod(generateSpecificGet(table, entityTable, count));
                count++;
            }
        }

        accessorBuilder.addJavadoc(GeneratorHelper.getJavaDocHeader("Accessor for Cassandra entity - {@link " +
                ClassName.get(MetaData.instance.getTableNamespace(), rawName) + "}", MetaData.instance.getUpdateTime()));

        JavaFile javaFile = JavaFile.builder(namespaceToUse, accessorBuilder.build()).build();

        Disk.outputFile(javaFile);
    }
}
 

import com.datastax.driver.mapping.annotations.Accessor; //导入依赖的package包/类
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory context) throws BeansException {
	ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false) {

		@Override
		protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
			return beanDefinition.getMetadata().isInterface();
		}

	};
	scanner.addIncludeFilter(new AnnotationTypeFilter(Accessor.class));
	for (BeanDefinition bd : scanner.findCandidateComponents(basePackage)) {
		Class<?> accessorCls;
		try {
			accessorCls = Class.forName(bd.getBeanClassName());
		} catch (ClassNotFoundException e) {
			throw new AssertionError(e);
		}
		log.info("Creating proxy accessor: " + accessorCls.getName());
		MethodInterceptor interceptor = new MethodInterceptor() {

			private final Lazy<?> target = new Lazy<>(() -> {
				log.info("Creating actual accessor: " + accessorCls.getName());
				Session session;
				if (AccessorScannerConfigurer.this.session == null)
					session = mainContext.getBean(Session.class);
				else
					session = AccessorScannerConfigurer.this.session;
				MappingManager mappingManager = new MappingManager(session);
				return mappingManager.createAccessor(accessorCls);
			});

			@Override
			public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
				if ("toString".equals(method.getName())) {
					return accessorCls.getName();
				}
				return method.invoke(target.get(), args);
			}

		};
		Enhancer enhancer = new Enhancer();
		enhancer.setInterfaces(new Class<?>[] { accessorCls });
		enhancer.setCallback(interceptor);
		Object bean = enhancer.create();
		String beanName = StringUtils.uncapitalize(accessorCls.getSimpleName());
		context.registerSingleton(beanName, bean);
		log.info("Bean registed, name=" + beanName + ", bean=" + bean.toString());
	}
}