框架 - 分类 - ISLAND

Ktor整合nacos注册中心

Tue, 03 Nov 2020 08:56:31 +0000

说起微服务，对于一直使用 java 生态的用户来说，首先想到的应该是 spring cloud 。Spring cloud 已经成为了 java 微服务中重要的标杆。但是同样是 jvm 语言的 kotlin 就没有这样好的环境了，虽然 kotlin 可以使用 spring 生态，而且 spring 在逐步整合 kotlin 的特性。

ktor 是 JetBrains 开发的 kotlin 框架，完全基于 kotlin。kror 提供了官方提供了很多 feature 使用。但是在使用过程中总会有一些功能是官方没有提供的。这时候就需要我们自己去完成。

什么是 feature

ktor 程序是有一系列的feature组成的。通过feature，我们可以自由的更改请求和响应。通过 install 方法将 feature 安装到应用里。例如：

fun Application.main() {
    install(DefaultHeaders)
    install(CallLogging)
    install(Routing) {
        get("/") {
            call.respondText("Hello, World!")
        }
    }
}

而官方提供的一系列 feature 中，不可能满足我们所有的需求，此时就需要自定义我们的feature。

自定义 feature

针对自定义feature，官方也给了一篇简短的文档来说明如何自定义。定义一个 feature 主要是实现新的 ApplicationFeature 接口的伴生对象，并且去实现它的方法。

这里面主要有一个属性 key 和一个方法 install 。

public val key: AttributeKey<TFeature>

public fun install(pipeline: TPipeline, configure: TConfiguration.() -> Unit): TFeature

key 属性是一个唯一的标识，用来标识当前的 feature。而 install 方法为 feature 的主要实现功能。

在 install 方法中可以初始化 feature 功能。

服务注册 feature

通过查阅 nacos 的官方文档，可以了解到如何将服务注册到 naocs 上。在install里完成逻辑代码，install里面的逻辑只会执行一次，但是如果想每次请求和响应都需要执行方法，那么可以使用 pipeline.intercept 。

以下是 naocs 的注册实现，当然还有很多功能去完成。方法内有 NacosCOnfig 方法，通过该方法来读取 ktor 的 application.conf 配置文件。其中一些配置是我们需要写在 application.conf 中的，比如 nacos 的端口和地址。

nacos {
    port: 8848
    address: 127.0.0.1
}

@KtorExperimentalAPI
override fun install(pipeline: ApplicationCallPipeline, configure: Configuration.() -> Unit): NacosDiscover {
    val nacosConfig = NacosConfig()
    val config = HoconApplicationConfig(ConfigFactory.load())
    val ktorConfig = config.config("ktor")
    val ktorPort = ktorConfig.propertyOrNull("deployment.port")?.getString()?.toInt() ?: 8080
    val configuration = Configuration().apply(configure)
    val feature = NacosDiscover(configuration)
    val addr = InetAddress.getLocalHost();
    val serverAddress = addr.hostAddress
    // 应用启动时进行
    val naming = NamingFactory.createNamingService("${nacosConfig.nacosAddress}:${nacosConfig.nacosPort}")
    val instance = Instance()
    instance.ip = serverAddress
    instance.port = ktorPort
    instance.serviceName = feature.serverName
    instance.isHealthy = true
    val mateData = HashMap<String, String>()
    mateData["framework"] = "ktor"
    instance.metadata = mateData
    naming.registerInstance(feature.serverName, instance)
    return feature
}

具体代码可以看 Github ktor-nacos ,这样就完成了服务注册。

服务请求

当服务注册到 naocs 上的时候，此时就需要通过客户端进行请求。所以需要编写客户端的 feature。

客户端的 feature 主要作用是通过服务名获取服务的详细信息，然后去请求对应的服务。

override fun install(feature: NacosClient, scope: HttpClient) {

    val nacosConfig = NacosConfig()
    val naming = NamingFactory.createNamingService("${nacosConfig.nacosAddress}:${nacosConfig.nacosPort}")
    scope.requestPipeline.intercept(HttpRequestPipeline.Render) {
        val instances = naming.getAllInstances(context.url.host).filter { it.isHealthy and it.isEnabled }
        val selectedNode = instances[currentNodeIndex]
        context.url.host = selectedNode.ip
        context.url.port = selectedNode.port
        currentNodeIndex = (currentNodeIndex + 1) % instances.size
    }
}

并且添加了负载均衡，每次将请求转发到不同的服务上。

总结

通过对 ktor 的基本了解，主要是通过编写 feature 和 pipeline 进行插件功能的实现。目前 ktor 的生态还很不完善，只提供了基础的组件，还有很多组件需要自己去整合完成，还需要社区不断的贡献。

项目已经开源到Github上。youngxhui/ktor-nacos

补充一个 ktor 资源网站 https://www.kotlinresources.com/#

参考链接

https://ktor.io/docs/advanced-features.html

https://github.com/piomin/sample-kotlin-ktor-microservices

Ktor 入门

Sat, 02 Feb 2019 14:54:34 +0000

前言

最近要使用 netty 作为消息推送，之前一直想着集成在 Springboot 中使用，但是转念一想，netty 本身就可以作为服务器，为什么不再开一个服务呢？于是就想到了使用 Ktor 构建一个服务。

Ktor 是一个使用强大的 Kotlin 语言在互联系统中构建异步服务器与客户端的框架。并且正在努力的向其他平台构建，比如 JavaScript，iOS 和 Android ，且逐步尝试支持原生环境( Native )。

使用 Ktor 可以很快的写出一个 HelloWorld

工欲善其事必先利其器

ktor 是以 kotlin 为基础的一个异步框架，那么开发采用 IDEA 成了我们更加友好的选择。

在 IDEA 中 setting Plugins 中的 MarketPlace 搜索 Ktor 。我们安装这个插件将更快的初始化我们的项目。

完成了基础工作，就可以开始我们的 Ktor 之旅了。

Hello World

暂时不需要选择任何模块。之后便可以下一步下一步等，直到项目建立。

在 gradle 界面选择 auto-import

此时只要耐心等待所有的依赖安装完成

如果多次安装失败可以修改一下gradle的地址,将原有地址注释掉，修改为阿里镜像。这样安装速度会很快，而且不容易失败

repositories {
    mavenLocal()
    //jcenter()
    maven { url 'https://maven.aliyun.com/nexus/content/groups/public' 
}

当项目构建完成的时候，在 src 目录下 Application.kt 中已经为我们生成了部分代码。

fun main(args: Array<String>): Unit = io.ktor.server.netty.EngineMain.main(args)

@Suppress("unused") // Referenced in application.conf
@kotlin.jvm.JvmOverloads
fun Application.module(testing: Boolean = false) {
}

开始编写我们的代码。

在 Application.module 中，编写我们要使用的路由。

fun Application.module(testing: Boolean = false) {
    routing {
        get("/") {
            call.respondText("Hello World")
        }
    }
}

启动项目，访问 http://127.0.0.1:8080 此时就可以看到我们的 Hello World。

routing 是 Ktor 中的核心模块，所以我们可以直接去使用。

构建一个 HTML 页面

ktor 中有 HTML DSL ，所以我们可以直接使用 Kotlin代码构建一个 html 页面。添加 html dsl 依赖

 compile "io.ktor:ktor-html-builder:$ktor_version"

之后就可以愉快的写 dsl 了

get("/") {
            call.respondHtml {
                head {
                    title {
                        +"Ktor 入门"
                    }
                }
                body {
                    a {
                        href = "http://127.0.0.1:8080/register"
                        +"注册"
                    }

                    form {
                        action = "http://127.0.0.1：8080/user/login"
                        method=FormMethod.post
                        input {
                            type = InputType.text
                            value = ""
                            name="username"
                        }
                        input {
                            type = InputType.password
                            value = ""
                            name="password"
                        }
                        input {
                            type = InputType.submit
                            value = "登录"
                        }
                    }
                }
            }
        }

重新启动一下

此时我们的页面就出现了。

目前这个表单无法访问 action 地址已向 ktor 提交 Issues

用Locations路由

但是当我们的路由很多的时候，如果都写在一个文件里，不仅仅文件回变得很大，而且不利于维护和团队协作。所以有了另一个模块 locations 。

首先要安装这个模块，在 gradle 中添加，注：功能目前还是实验性功能

dependencies {
    compile "io.ktor:ktor-locations:$ktor_version"
}

安装完成后启动我们的模块。

fun Application.module(testing: Boolean = false) {
    install(Locations) // 启用 Locations
    routing {
      // ...
    }
}

首先是编写 route 采用 class 的形式

@Location("/user")
class User {
    @Location("/login")
    data class UserLogin(val username: String, val password: String)

    @Location("/register")
    data class UserRegister(val username: String, val password: String)
}

该代码目前必须和 Application 在一起。

我们这样就编写了我们的路由和子路由。

新建一个 UserController.kt

fun Route.user() {
    post<User.UserLogin> {
        call.respondText("登录成功")
    }

    post<User.UserRegister> { user ->
        run {
            call.respondText("用户 ${user.username} ${user.password}")
        }
    }
}

并且在我们的 Application 文件中声明该路由即可。

   routing {
       // …………
        user()
       
       //…………
   }

此时访问的时候就可以访问到我们的子路由。

参考资料

Ktor 中文网 https://ktor.kotlincn.net/

打个广告

开发的小程序生活小程序

Spring Boot Security 跨域请求配置

Sat, 26 Jan 2019 08:38:26 +0000

前言

之前的项目一直没有加 token 作为校验，这样的话势必会出现安全隐患。所以在项目维护的时候就添加了 JWT 和 Spring Security 作为安全防护。然而紧接着出现了一个问题，无法进行跨域请求。

项目介绍

这个项目是我之前一直在做的一个在线自动评测系统，包括客观题和主观题。后端采用 Spring Boot ，前端之前使用 vue，结果写前端的同学找工作去了，而且前端的代码很多不规范的地方，所以借此机会就打算把前端重写一次。写之前比较了 vue react 和 angular。最后选择了 Angular，毕竟 typescript 和依赖注入还有 Rxjs 这几个技术太骚了。😂

遇到问题

当重写前端的时候，采用 .http 文件测试也是可以发送和接收到请求的，然而通过 Angular 的时候发现，请求报错，出现了跨域的问题，这里说明一下，之前没有使用 Security 的时候也是处理的跨域的问题。这里贴一下代码。

@Configuration
class CorsConfig : WebMvcConfigurer {

    /**
     * 跨域请求配置
     * @param registry 跨域请求
     */
    override fun addCorsMappings(registry: CorsRegistry) {
        registry.addMapping("/**")
            .allowedOrigins("*")
            .allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS")
            .allowCredentials(false)
            .maxAge(3600)
    }
}

我一直认为是前端没有处理好跨域的问题，查看了很多 Angular 的文档，并没有找到问题，于是乎我感觉到了，一定是后端的问题。紧接着想到了 Security 里面的一个参数 cors 当我想到了这个问题的时候立马打开了后端代码。果然我的后端代码里，并没有写出来这个跨域问题。

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
class WebSecurityConfig : WebSecurityConfigurerAdapter() {

    /**
     * 拦截请求配置
     * @param http 要拦截的请求
     */
    @Throws(Exception::class)
    override fun configure(http: HttpSecurity) {
        // 跨域配置
        http.cors()
      
        // 下面代码省略 ...

    }
}

此时我们重启应用，前端再次发送请求，请求成功。

RabbitMQ 和 Spring Boot 的集成

Fri, 23 Feb 2018 18:48:51 +0000

前言

在最近的项目中使用了 RabbitMQ。主要是用来起到一个消峰作用。

安装

安装这里分为 windows 和 linux。

我主要的开发环境是在 windows 10 上，运行环境是 linux(ubuntu)，所以讲解主要从两个系统来说。

windows

RabbitMQ 是 erlang 开发的，所以使用之前首先要下载 erlang 选择 windows 64bit 或者 windows 32bit 根据自己电脑进行选择，下载。

下载后进行安装将 erl 的安装目录下载的 bin 写入环境变量中。如图所示：

在 cmd/powershell 中输入 erl 会出现 erl 的一些版本信息。

这样基本完成了 erlang 的安装。

安装完 erlang 那么就应该安装我们的主角 RabbitMQ 。

首先下载 RabbitMQ ，在下载页面下载对应的安装包 exe 文件。

下载完成之后进行安装

安装完成之后就是我们的 RabbitMQ 就可以进行启动了。

运行

linux

这里使用的是 ubuntu 16.04 STL 发行版。

首先要安装 erlang 的相关环境

sudo apt-get install erlang

当安装完成之后在控制台输入 erl ，会有erl的版本信息。

此时的 erl 就算安装成功了。

安装完成之后我们就可以开始安装 RabbitMQ 了。

在终端中输入

sudo apt-get install rabbitmq-service

此时的 rabbitmq 就算安装成功了。

我们需要安装一些插件。

sudo rabbitmq-plugins enable rabbitmq_management

就可以完成插件的安装

当我们通过浏览器访问的时候

此时的默认账户是无法登录的，因为默认 guest 是只能通过本地访问。所以我们要新建一个账户用来可以远程访问。

rabbitmqctl add_user admin admin # 新建一个叫admin账户和密码为admin
rabbitmqctl set_user_tags admin administrator # 为admin账户设为administrator用户
rabbitmqctl set_permissions -p "/" admin ".*" ".*" ".*" # 为账户写入权限

与SpringBoot整合

基本的安装如上所示，下面将会将如何与 SpringBoot 整合

说明：项目采用 .yml 格式文件作为 application 配置文件，采用 Gradle 作为构建工具，语言采用 kotlin

配置文件

首先我们对项目添加依赖。

dependencies {
   	//……
    // mq
    compile('org.springframework.boot:spring-boot-starter-amqp')
}

对 application.yml 进行配置

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: admin
    password: admin

在代码中进行配置

我们新建一个类用来配置 RabbitMQ。

在代码中新建了一个队列叫做 dc_check，当我们启动服务的时候就可以在 RabbitMQ 的控制台上看到这个队列

package com.nuc.evaluate.config

import org.springframework.amqp.core.Queue
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

/**
 * @author 杨晓辉 2018/2/6 16:07
 */
@Configuration
class RabbitConfig {

    @Bean
    fun checkAns(): Queue {
        return Queue("dc_check")
    }
}

这样我们基本完成了配置。

python 实现微信打飞机

Thu, 22 Jun 2017 10:27:42 +0000

微信打飞机 python 实现

所用技术和软件

python 2.7

pygame 1.9.3

pyCharm

准备工作

安装好 pygame 在第一次使用 pygame 的时候，pyCharm 会自动 install pygame。
下载好使用的素材。

技术实现

初始化 pygame

首先要初始化 pygame ，之后设定一些基本的要点，比如窗口大小（尽量避免魔法数字），窗口标题以及背景图像。pygame 通过加载图片，最后返回一个 surface 对象，我们不需要关系图片的格式。但是通过 convert() 这个函数，会使我们的图片转换效率提高。

# coding=utf8

import pygame

WIDTH = 480
HEIGHT = 800

pygame.init()

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption('飞机大战')

background = pygame.image.load('resources/image/background.png').convert()

screen.fill(0)
screen.blit(background, (0, 0))

默认图片左上角为原点 (0,0)。

显示窗口

如果我们这样设定，当我们运行的时候，窗口会一闪而过，并不会出现我们想象的画面。因为窗口只是运行一下就会关闭，所以我们要写一个循环，使窗口一直保持出现。当然如果我们简单的写一个 while True那么我们的程序就出现了死循环，卡死。

所以还需要写个退出。

while True:
    screen.fill(0)
    screen.blit(background, (0, 0))

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

显示飞机

首先我们要初始化我们的主角飞机

仍旧需要加载我们需要的资源，我们的资源文件里已经准备好各种各样的飞机，但是他们都在一张切图上。

同时我们的资源文件里还有一个叫做 shoot.pack 的文件，里面记录了每个图片所在的位置。

我们通过下面的代码加载资源图片，并且获得我们需要的主角飞机。

plane_img = pygame.image.load('resources/image/shoot.png')

player = plane_img.subsurface(pygame.Rect(0, 99, 102, 126))

将 player 显示在屏幕上，并且刷新屏幕

screen.blit(player, [100, 400])

pygame.display.update()

效果如下

让飞机 “飞” 起来

飞机已经出现在我们的屏幕上了，现在需要让飞机动起来让他可以上下左右的移动。

首先要获取键盘事件，获取键盘上什么按键被按下。

key_pressed = pygame.key.get_pressed()

通过 key_pressed 获取当前的键盘按键。并进行判断，这里写了四个函数进行对 player 移动。

if key_pressed[pygame.K_w] or key_pressed[pygame.K_UP]:
    player.moveUp()
if key_pressed[pygame.K_s] or key_pressed[pygame.K_DOWN]:
    player.moveDown()
if key_pressed[pygame.K_a] or key_pressed[pygame.K_LEFT]:
    player.moveLeft()
if key_pressed[pygame.K_d] or key_pressed[pygame.K_RIGHT]:
    player.moveRight()

下一步就是完善这四个方法。

简单的说就是按下方向键的时候(w,a,s,d)飞机向四周移动，但是不能移动离开屏幕。

此时我们就应该把我们的飞机形成一个类，类里面有控制飞机的方法。

这里写类比较麻烦一点

Player的出现

首先要明确一点，这个类需要什么。

我们之前对 player 有什么操作？定义了他的图片和他出现的位置。所以我们的构造方法就要初始化这些值。所有的这些对象，我们在 pygame 里叫做精灵(sprite)，这个概念也在其他游戏开发中使用。

class Player(pygame.sprite.Sprite):
    def __init__(self, plane_img, player_rect, player_position):
        pygame.sprite.Sprite.__init__(self)
        self.img = plane_img.subsurface(player_rect)
        self.rect = player_rect
        self.rect.topleft = player_position

简单的说就是获取飞机的图片，初始化飞机的矩形区域。rect 该属性会获得四个值。分别是左上角 x ,y 坐标，矩形的宽度。topleft 初始化飞机的左上角坐标，也就是飞机出现的位置。如下图所示。

player的控制

当飞机出现了，我们就应该实现我们在循环里写的方法。我们首先要判断它还在不在屏幕内，不能让飞机飞出屏幕。可以通过 rect.top,rect.bottom,rect.left,rect.right四个方法获取飞机图片的上下左右四个边界值。

这样我们就能对飞机进行判断

    def moveUp(self):
        if self.rect.top <= 0:
            self.rect.top = 0
        else:
            self.rect.top -= self.move

    def moveDown(self):
        if self.rect.bottom >= HEIGHT:
            self.rect.bottom = HEIGHT
        else:
            self.rect.bottom += self.move

    def moveLeft(self):
        if self.rect.left <= 0:
            self.rect.left = 0
        else:
            self.rect.left -= self.move

    def moveRight(self):
        if self.rect.right >= WIDTH:
            self.rect.right = WIDTH
        else:
            self.rect.right += self.move

这里的 move 是我们对飞机的移动的位移定义的常量。

让子弹飞

子弹要沿着发射方向射出去。可以在屏幕上一直移动，直到移出屏幕。我们只要有定义一个子弹对象，让这个对象显示在屏幕上就可以。先定义飞机子弹类，基本和定义 player 一样，获得图片，裁剪图片，设置图片初始位置，在屏幕上显示图片

class Bullet(pygame.sprite.Sprite):
    def __init__(self, bullet_image, bullet_position):
        pygame.sprite.Sprite.__init__(self)
        self.image = bullet_image
        self.rect = self.image.get_rect()
        self.rect.midbottom = bullet_position


        
# 省略其他代码

# 加载子弹图片
bullet_rect = pygame.Rect(69, 78, 9, 21)
bullet_img = plane_img.subsurface(bullet_rect)

# 省略其他代码

while True:

    # 省略其他代码
    
    screen.blit(bullet.img, bullet.rect)
    
    # 省略其他代码

运行结果

下一步就是让飞机的子弹跟随飞机。我们需要在 Player 类里面添加方法。首先我们规定，按下空格发射子弹。

    if key_pressed[pygame.K_SPACE]:
        player.shoot()

完善shoot方法。子弹类已经有了，我们每次只要在按下空格的时候创建一个对象就好。首先要每次传入一个子弹的图像，然后还有出现位置，这样子弹才能跟随飞机。定义一个pygame.sprite.Group() 来存放精灵组。这样我们就能把我们的子弹都放进去。

     def shoot(self, bullet_img):
        bullet = Bullet(bullet_img, self.rect.midtop)
        self.bullets.add(bullet)

每次按下空格的时候传入一个子弹图片

    if key_pressed[pygame.K_SPACE]:
        player.shoot(bullet_img)

最后我们只需要在屏幕上进行子弹的绘制即可。

player.bullets.draw(screen)

这样我们的子弹就会跟随飞机出现。

下一步就是让子弹在屏幕上移动。

创建移动的方法。

    def move(self):
        self.rect.top -= self.move

因为我们的子弹在 bullets 里，所以我们仅需要一个循环，遍历每个子弹，之后移动即可。当子弹移出屏幕的时候我们只要在 bullets 中移出就可以。


    for bullet in player.bullets:
        bullet.bulletMove()
        if bullet.rect.bottom < 0:
            player.bullets.remove(bullet)

结果

这个和我们的预期还是有差别的，频率太快了。

关于pygame 的键盘重复事件官方好像并没有这个设置。那么我们只能在添加一个计数器，通过计算器的数值来判断子弹是否发射。这里的数值是多次测试后，自己感觉一个比较满意的频率。可以自己调整。

# 省略其他代码

# 子弹频率
SHOOT_PC = 0

在键盘事件中我们需要判断频率。

    if key_pressed[pygame.K_SPACE]:
        SHOOT_PC = SHOOT_PC + 1
        if SHOOT_PC % 400 == 0:
            player.shoot(bullet_img)

player 的飞机就算基本绘制好了

绘制敌机

下一步就是绘制敌机。敌机是从屏幕上方移动到屏幕下方。我们任就需要一个类来设置敌机。设置类任就和我们前面的差不多，加载资源，设置 rect，设置位置。


# 加载敌机图片

enemy_rect = pygame.Rect(267, 347, 57, 51)
enemy_img = plane_img.subsurface(enemy_rect)
enemy_position = [200, 200]
enemy = Enemy(enemy_img, enemy_position)


# 敌机类

class Enemy(pygame.sprite.Sprite):
    def __init__(self, enemy_img, enemy_position):
        pygame.sprite.Sprite.__init__(self)
        self.image = enemy_img
        self.rect = self.image.get_rect()
        self.rect.topleft = enemy_position

最后在屏幕显示出来

screen.blit(enemy_img, enemy_rect)

现在我们就应该想想敌机的特点了，其实他和子弹的特点基本一直，只不过方向不一样而已。还有一点是敌机是随机生成的。

# 敌机计数器
EnEMY_PC = 0
# 省略代码
enemy_position = [random.randint(0, WIDTH - enemy_rect.width), 0]
        enemy = Enemy(enemy_img, enemy_position)
        enemies.add(enemy)

我们随机在顶部生成飞机。

这个方式的情况和子弹其实差不多，我们应该给出现敌机确定一个频率。

    if EnEMY_PC % 500 == 0:
        enemy_position = [random.randint(0, WIDTH - enemy_rect.width), 0]
        enemy = Enemy(enemy_img, enemy_position)
        enemies.add(enemy)

    EnEMY_PC = EnEMY_PC + 1

这样的话出现情况就变得缓慢。下一步实现敌机的移动。敌机的移动原理和子弹的移动其实也是一样的。不多解释

移动方法

    def enemyMove(self):
        self.rect.top += self.move

移动实现

 for enemy in enemies:
        enemy.enemyMove()
        if enemy.rect.top > HEIGHT:
            enemies.remove(enemy)

    enemies.draw(screen)

碰撞检测

飞机和敌机还有子弹都有了，我们现在需要进行完成碰撞检测。有下面几种场景。

敌机和玩家碰撞在一起
子弹和敌机碰撞在一起

无论是那种情况的碰撞，其实就是两张图片有了交集。如图 pygame 给我们提供了碰撞检测的方法。首先两个对象必须是 sprite 。通过 pygame.sprite.collide_rect() 进行碰撞检测。

我们先进行一个测试

    if pygame.sprite.collide_rect(enemy, player):
        print '检测成功'

结果

检测成功

此时我们就可以完成,当玩家和敌机发生碰撞,游戏结束,当子弹和敌机碰撞,敌机消失。

同样的 pygame 给我们提供了一个 pygame.sprite.groupcollide() 用于 Group 之间的碰撞检测.当发生碰撞的时候这两个对象都会在 Group 中移出。

用于检测敌机和子弹

pygame.sprite.groupcollide(enemies, player.bullets, 1, 1)

敌机和子弹的关系已经和好的处理。处理敌机和玩家飞机的关系。

我们需要在 Player 里添加一个属性判断当前玩家是否被击中的 boolean 值.当集中的时候把属性改为 True.当为 True 的时候游戏结束.也就是我们一开始设置的循环就会结束.所以我们需要更改之前写的一些代码,使它更加完善。

在 Player 类里面添加是否击中属性。

self.is_hit = False

修改循环

RUN = True

while RUN:
    # 省略代码
        if pygame.sprite.collide_rect(enemy, player):
        player.is_hit = True
        RUN = False
    # 省略代码

执行结果

当玩家被击中的时候,在显示一张 GameOver 图片提示

gameOver = pygame.image.load('resources/image/gameover.png')

while GAMEOVER:
    screen.fill(0)
    screen.blit(gameOver, (0, 0))

    pygame.display.update()

    # 退出程序
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

做到这里基本算是实现了飞机大战.但是还有很多细节处理。

细节处理

精细的碰撞检测

从图上看,当敌机看似还没有和我们接触时,但是已经 GameOver 了。实际情况是这样的,所有的图片都是矩形,当两张图片的矩形边框线碰撞的时候,就算两个对象碰撞,所以我们要更加精细的使用碰撞检测。

我们可以按着图片中心的某个长度为半径，在这个半径内发生碰撞才是碰撞。

pygame 给我们提供了这样的方法。pygame.sprite.collide_circle_ratio() 可以自己算出一个半径，作为检测半径。并且可以做出一个有效检测的百分比。

    if pygame.sprite.collide_circle_ratio(0.6)(player, enemy):
        player.is_hit = True
        RUN = False

同样，子弹和敌机也可以修改，让碰撞检测更加精细。修改后面的两个参数，使得碰撞检测更加精细。

pygame.sprite.groupcollide(enemies, player.bullets, 0.6, 0.8)

动画

做了怎么就，感觉它没有一点动效，感觉死气沉沉的。无论是飞机飞行，还是飞机被击中，都没有一个明确的反馈。对于2d游戏，动画其实就是一张一张的图片不停的变化。就和电影的原理类似。要想让我们的飞机动起来，我们需要定义一个列表来存放这些图片，然后写个循环，让他一直不停的更换图片就好。

首先我们更改我们的主角 Player 任就是老套路，加载图片。把加载的图片放到list 里。

player_rect = [pygame.Rect(0, 99, 102, 126),
               pygame.Rect(165, 360, 102, 126),
               pygame.Rect(165, 234, 102, 126),
               pygame.Rect(330, 624, 102, 126), 
               pygame.Rect(330, 498, 102, 126), 
               pygame.Rect(432, 624, 102, 126)]

player_position = [100, 400]
player = Player(plane_img, player_rect, player_position)

之后在 Player 添加循环的方法。获取图片。

class Player(pygame.sprite.Sprite):
    def __init__(self, plane_img, player_rect, player_position):
        pygame.sprite.Sprite.__init__(self)
        self.image = []
        for i in range(len(player_rect)):
            self.image.append(plane_img.subsurface(player_rect[i]).convert_alpha())
        self.rect = player_rect[0]
        self.rect.topleft = player_position
        self.img_index = 0
        self.move = 1
        self.bullets = pygame.sprite.Group()
        self.is_hit = False

飞机正常飞行的图片只有两张。所以我们要循环变化这两张图片。所以每发射一个子弹，图片变化两张。


    screen.blit(player.image[player.img_index], player.rect)
    player.img_index = SHOOT_PC / 248
    # 省略代码
    if key_pressed[pygame.K_SPACE]:
        if SHOOT_PC % 495 == 0:
            player.shoot(bullet_img)
        SHOOT_PC = SHOOT_PC + 1
        if SHOOT_PC >= 495:
            SHOOT_PC = 0

正常发射子弹的动画效果已经做完。我们还需要进行被击中爆炸的动画效果。

击中的原理和正常也一样。只不过先要判断当前飞机状态，是否被击中。

    if not player.is_hit:
        screen.blit(player.image[player.img_index], player.rect)
        player.img_index = SHOOT_PC / 248
    else:
        player.img_index = player_shoot / 248
        screen.blit(player.image[player.img_index], player.rect)
        player_shoot += 30
        if player_shoot > 495:
            RUN = False

    # 省略代码
    if pygame.sprite.collide_circle_ratio(0.6)(player, enemy):
        player.is_hit = True

248，30，495，1457 这些数字是什么？如何计算出来的。先说 495 这个数字。 495 这个数字很随便，只是控制子弹的发射间隔。完全可以自定义。但是495这个数字一旦确定，其他三个数字基本确定。 248 为 495 的一半，因为发射一个子弹，图片要变化两张。 30 这个数字基本也是自定义的，只要比1大就好，他影响了结束动画出现的时间。

1488 这个数字是通过 248 确定的，是 248 的 6倍，因为飞机被射击后会有四张图片的显示。同理，把敌机接触子弹的动画写出来。

加载图片

enemies_shoot_img = [plane_img.subsurface(pygame.Rect(267, 347, 57, 43)),
                     plane_img.subsurface(pygame.Rect(873, 697, 57, 43)),
                     plane_img.subsurface(pygame.Rect(267, 296, 57, 43)),
                     plane_img.subsurface(pygame.Rect(930, 697, 57, 43))]

同样我们需要创建 Group() 来存放被击中的敌机。

enemies_shoot = pygame.sprite.Group()

之后的处理逻辑基本相似，不多介绍

    for enemy in enemies:
        enemy.enemyMove()
        if pygame.sprite.collide_circle_ratio(0.6)(player, enemy):
            enemies_shoot.add(enemy)
            enemies.remove(enemy)
            player.is_hit = True
            break
        if enemy.rect.top > HEIGHT:
            enemies.remove(enemy)

    for enemy_shoots in enemies_shoot:
        if enemy_shoots.shoot_index == 0:
            pass
        if enemy_shoots.shoot_index > 70:
            enemies_shoot.remove(enemy_shoots)
            continue
        screen.blit(enemy_shoots.shoot_imgs[enemy_shoots.shoot_index / 20], enemy_shoots.rect)
        enemy_shoots.shoot_index += 1

这样的话基本完成了动画效果。

音乐

有了动画还的有音乐。

音乐的处理只要在特定的地方播放音乐就好，比如子弹发射的时候，背景音乐，被击中的时候，游戏结束的时候，等等。他们的处理逻辑都一样。先加载资源，然后在播放。

背景音乐的播放。

pygame 在处理背景音乐的时候都在 pygame.mixer 方法中。其中播放音乐的play中的参数，第一个为播放几次，-1 为循环播放，后面的浮点表示从第几秒开始播放。

backgroundMusic = pygame.mixer.music.load('resources/sound/game_music.mp3')
pygame.mixer.music.play(-1, 0.0)

其他的音乐先加载资源，在需要的地方播放。

发射子弹

 def shoot(self, bullet_img):
        shootMusic = pygame.mixer.Sound('resources/sound/bullet.mp3')
        bullet = Bullet(bullet_img, self.rect.midtop)
        self.bullets.add(bullet)
        shootMusic.play()

其他音乐处理一样，不多解释。

分数&等级

分数

首先绘制得分情况，在屏幕上显示多少分。

绘制字体基本和绘制精灵是差不多的。首先要生成字体两个参数分别是字体和字号

score_font = pygame.font.Font(None, 36)

有了字体那么需要写点字。

score_font.render("分数",True,(0,0,0),(255,255,255))

第一个参数是写的文字；第二个参数是个布尔值，以为这是否开启抗锯齿，就是说True的话字体会比较平滑，不过相应的速度有一点点影响；第三个参数是字体的颜色；第四个是背景色，如果你想没有背景色（也就是透明），那么可以不加这第四个参数字体也有了，文本也有了，下一步就是绘制。通过 get_rect() 获得矩形，之后绘制和精灵绘制方法一样

    score_font = pygame.font.Font(None, 36)
    score_text = score_font.render('分数：0', True, (128, 128, 128))
    text_rect = score_text.get_rect()
    text_rect.topleft = [10, 10]
    screen.blit(score_text, text_rect)

分数已经显示了，就可以积分。我们每击落一个飞机增加 100 分。

 if enemy_shoots.shoot_index > 70:
            enemies_shoot.remove(enemy_shoots)
            score += 100
            continue

我们还需要在文本的地方强制转换为 str 。

score_text = score_font.render(str(score), True, (128, 128, 128))

等级

有了分数，那么再加点等级会使游戏更加有趣味性。

同样的先绘制等级。

    level_font = pygame.font.Font(None, 42)
    level_text = level_font.render('Level '+str(level), True, (128, 128, 128, 128))
    level_rect = level_text.get_rect()
    level_rect.midtop = [240, 10]
    screen.blit(level_text, level_rect)

下一步就是写等级函数。随着分数的增加，等级增加，飞机变多，等等。首先写分数和等级的关系。随便瞎写的函数

 if score == 100 * (level ** 2 + level):
        level += 1

这个是控制敌机数量的，我们可以设定一个变量，使敌机越来越多。

if ENEMY_PC % 500 == 0:

每增加一级，就添加敌机数量。等级也不能一直增加，所以当等级是摸个值的时候，就算最高级别了。

    if score == 100 * (level ** 2 +  level):
        level += 1
        if level != 10:
            enemy_add -= 20

基本到这里算是写了一个相对完整的游戏。

代码

Github地址

Spring学习记录(二)

Thu, 02 Mar 2017 20:29:13 +0000

AOP简述

面向切面编程，扩展功能不修改源代码实现。AOP采用横向抽取机制，取代了传统的纵向继承体系重复代码。

AOP底层原理

AOP操作相关术语

链接点：类里面的被增强的方法。
切入点：类里面的增强的方法，在实际操作中，实际增强的方法叫切入点。
通知/增强：增强的逻辑，称为增强，比如扩展日志功能，这个日志功能称为增强。前置通知：在方法之前执行后置通知：在方法之后执行异常通知：出现异之后执行最终通知：在后置之后执行环绕通知：在方法之前和之后执行
切面：把增强应用到具体的方法上面，这个过程称为切面。把增强用到切入点的过程。

Spring的AOP操作

Aspectj框架

在Spring进行aop操作，使用Aspectj框架，这个框架本身不是Spring的一部分，只是一起使用进行AOP操作。

版本在2.0以后支持切点表达式支持。

基于Aspectj实现AOP操作

相关ja包

aopalliance,aspectjweaver,spring-aop,spring-aspects

创建Spring核心配置文件导入AOP约束。

 xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

基于Aspectj的xml实现

常用表达式通过execution函数表达式实现。

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

execution(* /增强方法的全路径/): *代表任意修饰符，空格后跟随增强方法的全路径。
execution(* com.Hello.*):代表该类的所有方法
execution(* .(..))
execution(* save*(..)) 表示以save开头的方法进行增强。

xml配置代码


     id="book" class="aop.Book"/>
     id="myBook" class="aop.MyBook"/>
    
    
        
         id="pointcut1" expression="execution(* aop.Book.add())"/>
        
         ref="myBook">
             method="before1" pointcut-ref="pointcut1"/>

基于Aspectj的注解实现

创建类的对象，在spring的配置文件中开启aop操作。

通过注解来实现。

在增强类上 @Aspect注解类，@Before注解方法(前置通知)。

@Before
@AfterReturning
@Around
@AfterThrowing
@After

Spring的JdbcTemplate操作

Spring在dao层，使用JdbcTemplate，Spring为各种支持的持久化技术，都提供了简单操作的模板和回调。

ORM持久化技术	模板类
JDBC	org.springframework.jdbc.core.JdbcTemplate
Hibemate5.0	org.springframework.orm.hibernate5.HibernateTemplate
IBatis(MyBatis)	org.springframework.orm.ibatis.sqlMapClientTempate
JPA	org.springframework.orm.jpa.JpaTempate

JdbcTemplate使用

都是对数据库进行crud操作。

导入JdbcTemplate相关jar包

spring-jdbc spring-tx

创建对象设置数据库信息，比如：加载驱动，设置url，用户名，密码等。实例代码

DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUsername("root");
        dataSource.setUrl("jdbc:mysql://localhost:3306/JdbcDemo");
        dataSource.setPassword("12qwaszx");

创建 JdbcTemplate模板对象，设置数据源。

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

调用JdbcTemplate对象里面的方法实现操作。

添加

    String sql = "INSERT INTO jdbcTest (id, name, password) VALUES (?,?,?)";
    jdbcTemplate.update(sql, "1", "lucy", "1234");

修改

    String sql = "UPDATE jdbcTest\n" +
                "SET name = ?\n" +
                "WHERE id=?";
    jdbcTemplate.update(sql,"cat","1");

删除

    String sql = "DELETE FROM jdbcTest WHERE name=?";
    jdbcTemplate.update(sql,"cat");

查询

JdbcTemplate实现查询，有接口RowMapper, JdbcTemplate针对这个接口美欧提供实现类，等到不同的类型数据需要自己封装

查询一个值

    //查询返回某值
    String sql1="SELECT count(*) FROM jdbcTest";
    int count=template.queryForObject(sql1,Integer.class);

返回对象

    //查询返回对象
    String sql2 = "select * from jdbcTest where name=?";
    //调用jdbcTemplate方法
    User user=template.queryForObject(sql2,new MyRowMapper() , "tom");
    System.out.println(user);

要自己封装这个类其中querForObject这个方法的第二个值为RowMapper，需要自己进行封装。 MyRowMapper.class

class MyRowMapper implements RowMapper<User> {
    @Override
    public User mapRow(ResultSet resultSet, int i) throws SQLException {
        //从结果集里面把数据得到
        String username = resultSet.getString("name");
        String password = resultSet.getString("password");
        //把数据封装到对象里面
        User user = new User();
        user.setName(username);
        user.setPassword(password);
        return user;
    }
}

返回list集合

        String sql3 = "select * from jdbcTest";
        List<User> list = template.query(sql3, new MyRowMapper());
        System.out.println(list);

Spring配置连接池和dao使用JdbcTemplate

配置c3p0连接池

导入jar包 c3p0和mchange-commons-java
在Spring的配置文件配置连接池
在dao中使用

dao使用jdbctemplate

在Service中注入Dao。
在Dao中注入jdbc模板。
在模板中注入连接池。
在连接池中写配置。

示例代码

UserService.class

package com.c3p0;

/**
 * Created by youngxhui
 * Time is 17-2-19.
 */
public class UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void add(){
        userDao.add();
    }
}

UserDao.class

package com.c3p0;

import org.springframework.jdbc.core.JdbcTemplate;

/**
 * Created by youngxhui
 * Time is 17-2-19.
 */
public class UserDao {
    private JdbcTemplate jdbcTemplate;
    public void add() {

        String sql="INSERT INTO jdbcTest (id, name, password) VALUES (?,?,?)";
        jdbcTemplate.update(sql, 5, "lili", "123456");

    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
}

SpringContext.xml


 xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    
     id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
         name="driverClass" value="com.mysql.jdbc.Driver"/>
         name="jdbcUrl" value="jdbc:mysql://localhost:3306/JdbcDemo"/>
         name="user" value="root"/>
         name="password" value="12qwaszx"/>
    

     id="userService" class="com.c3p0.UserService">
         name="userDao" ref="userDao"/>
    

     class="com.c3p0.UserDao" id="userDao">
         name="jdbcTemplate" ref="jdbcTemplate"/>
    

     class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
         name="dataSource" ref="comboPooledDataSource"/>

Spring事务管理

什么是事务

事务是访问数据库的一个操作序列，数据库应用系统通过事务集来完成对数据库的存取。事务的正确执行使得数据库从一种状态转换成另一种状态。

事务特性

原子性（atomicity）
一致性（consistency
隔离性（isolation）
持久性（durability）

Sping事务管理api

spring对事务管理的两种方式

编程式事务管理(不用)
声明式事务管理
- 基于xml配置文件实现
- 基于注解实现

api介绍

Spring事务管理高层抽象主要包含3个接口

PlatformTransactionManager事务管理器
TransactionDefinition事务定义信息
TransactionStatus事务具体运行状态

PlatformTransactionManager针对不同的dao层，提供了不同的接口实现类

事务	说明
org.springframework.idbc.datasource.DataSourceTransactionManager	使用Spring JDBC或iBatis进行持久化数据时使用
org.springframework.orm.hibernate5.HibernateTransactionManger	使用Hibernate5.0版本进行持久化数据时使用
org.springframework.orm.jpa.JpaTransactionManager	使用JPA进行持久化
org.springframework.jdo.JdoTransactionManager	当持久化机制是Jdo时使用
org.springframework.transaction.ita.JtaTransactionManager	使用一个JTA实现来管理事务，在一个事务跨越多个资源时必须使用

Log4j使用

Sun, 19 Feb 2017 14:25:11 +0000

简介

通过log4j可以看到程序运行时候更加详细的信息。

使用

导入log4j的jar包
复制log4j的配置文件

一个简单的log4j的配置文件

### 设置日志等级 ###
log4j.rootLogger=info, stdout
### 输出到控制台 ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
#log4j.appender.stdout=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### 输出到日至文件
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=/home/youngxhui/IdeaProjects/SpringDemo/spring-aop-xml/src/mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%{ABSOLUTE} %5p %c{1}:%L - %m%n

设置日志级别

info：基本信息
debug：更详细的信息

实例

Spring学习(一)

Wed, 08 Feb 2017 10:54:06 +0000

Spring学习笔记，仅供自己参考。

概述

Spring是开源的轻量级框架。
Spring核心主要为两部分： (1).AOP:面向切面编程 (2).IOC：控制反转：把对象的创建不是通过new的方式实现，而是交给spring配置创建类对象
Spring是一站式框架。 Spring在JavaEE三层结构中，每一层都提供不同的解决技术。

web层：SpringMVC
service层：Spring的ioc
dao层：Spring的jdbcTemplate

Spring版本：4.x

接口

用于沟通的中介勿的抽象化。
对外声明。
Java 8中接口可以拥有方法体。

面向接口编程

结构设计中，分清层次及调用关系，每层只能向外提供一组功能接口，更层次仅依赖接口而非实现类。
接口实现的变动不影响各层的调用。
隐藏具体实现和实现多态性的组件。

IOC 控制反转

什么是IOC

控制权的转移，应用程序本身不负责依赖对象的创建和维护，而是由外部容器负责创建和维护。把对象的创建交给spring进行管理

IOC操作的两种操作

IOC的基于配置文件方式
IOC的注解方式

IOC的底层原理

xml的配置文件
dom4j解决xml
工厂设计模式
反射

IOC案例

导入jar包

核心jar包 Beans Core Context, SpEL
支持日志输出的jar包

创建类，在类里面创建方法
创建spring的配置文件，配置创建类

建议放到src下面

测试对象创建

Spring的Bean管理(xml)

实例化三种方式

使用类的无参构造(主要使用方式)
静态工厂创建
实例工厂创建

Bean标签常用属性

id属性起名称，id的属性值可以是任意命名，但是不能包含特殊符号
class属性创建对象所在类的全路径
name属性功能和id属性是一样的，但是name属性可以包含特殊符号。
scope属性 singleton:默认值，单例对象。 prototupe:多例。 request:创建了对象，把对象放到request域里面。 session:创建对象，把对象放到session里面。 globalSession:创建对象，把对象放到globalSession里面。

Spring的Bean的管理(注解)

注解

代码里面的特殊标记，使用注解可以完成功能。
注解写法@注解名称(属性名称=属性值)。
注解使用在类上面，方法上面和属性上面。

在xml需要配置一下

  base-package="com.young.anno"/>

Bean管理常用注解

Component – 在Spring中提供的@Component三个衍生注解
- @Controller WEB层
- @Service 业务层
- @Repository 持久层这四个注解目前的功能是一样的，都是创建对象。

@Component(value = "user")
public class User {
    public void add(){
        System.out.println("add....");
    }
}

Scope 用于单例与多例等配置,写在Component的下面。

@Component(value = "user")
@Scope(value = "prototype") 
public class User {
    public void add(){
        System.out.println("add....");
    }
}

Autowired 注入属性
Resource name属性写创建dao对象的value值

DI 依赖注入

创建对象并且组装对象之间的关系

有参构造注入

采用constructor-arg来进行,name和value进行对构造器的值进行注入。

 id="preperty" class="com.young.property.PrepertyDemo1">
         name="username" value="zhangsan"/>

set方法注入

使用property标签进行注入，name定义类里面定义的属性的名称，value设置具体的值

 id="book" class="com.young.property.Book">
         name="bookname" value="one"/>

spring框架只支持set方法注入和构造器注入

注入对象类型属性

创建service类dao类
在service把dao作为类型属性
生成dao类型的set方法

xml配置方式

UserService.java

public class UserService {
    private UserDao userDao;
    public void add(){
        System.out.println("service");
        userDao.add();
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

配置文件

     id="service" class="com.young.ioc.UserService">
        
         name="userDao" ref="userdao">
    
     id="userdao" class="com.young.ioc.UserDao">

注解注入方式

Autowired

@Service(value = "userservice")
public class UserService {

    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("service");
        userDao.add();
    }
}

Resure

UserDao.java

@Component(value = "userdao")
public class UserDao {
    public void add() {
        System.out.println("UserDao");
    }
}

复杂类型注入

数组


         name="args">
            
                小马
                小宋
                小王
                小李子

list类型

     name="list">
            
                张三
                李四

map类型

     name="map">
            
                 key="a" value="张三"/>

properties

     name="properties">
            
                 key="name">root

xml和注解比较

比较项	xml	注解
添加		@Component
多例/单例		@Scope
对象类型注入		@Resource

配置文件与注解混合使用

案例：

BookDao.java

public class BookDao {
    public void book(){
        System.out.println("bookDao");
    }
}

OrderDao.java

public class BookDao {
    public void book(){
        System.out.println("bookDao");
    }
}

BookService.java

public class BookService {

    @Resource(name = "bookDao")
    private BookDao bookDao;
    @Resource(name = "ordlerDao")
    private OrderDao ordersDao;
    
    public void service(){
        System.out.println("service");
        bookDao.book();
        ordersDao.buy();
    }
}

配置文件


 xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
     base-package="com.young.xmlanno"/>
     id="bookservice" class="com.young.xmlanno.BookService"/>
     id="bookDao" class="com.young.xmlanno.BookDao"/>
     id="ordlerDao" class="com.young.xmlanno.OrderDao"/>

测试类


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    @org.junit.Test
    public void testxmlAnno(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bea2.xml");
        BookService bookService= (BookService) context.getBean("bookservice");
        bookService.service();
    }
}