xampp zend设置密码问题
点击联系发帖人
时间：2012-03-13 05:03
如何设置xampp的权限？
当前位置： >
如何设置xampp的权限？
如何设置xampp的权限？
如何设置xampp的权限？相关软件推荐下载：
所属栏目：
如何设置xampp的权限？相信大家都知道，在xampp中的mysql等用户名权限和密码都空白的，那么就需要我们自己动手更改设置，那么要如何设置xampp的权限呢？下面就请大家跟着小编一起来看看怎么设置吧！
1.首先要打开；
2.运行红框中的程序；
3.打开任意在地址栏中输入http://localhost/，弹出页面，选择语言为中文；()
4.点击左边的&安全&；
5.此时我们的数据库显示是不安全的，点击如下图所示的链接：
6.在1中输入mysql的密码，点击2，然后在3中输入用户名和密码，点击4就可以了；
以上就是设置xampp权限的具体操作步骤了！还不会设置的朋友就赶紧去操作试试吧！
上一篇文章：
下一篇文章：
已有条评论，
(您的评论需要经过审核才能显示,请文明发言！)
07-0307-0207-0207-0207-0207-0207-0207-0207-0207-02
可能你喜欢的软件
感谢您为本站写下的评论，您的评论对其它用户来说具有重要的参考价值，所以请认真填写。
类似"顶"、"沙发"之类没有营养的文字，对勤劳贡献的楼主来说是令人沮丧的反馈信息。
相信您也不想看到一排文字/表情墙，所以请不要反馈意义不大的重复字符，也请尽量不要纯表情的回复。
提问之前请再仔细看一遍楼主的说明，或许是您遗漏了。
请勿到处挖坑绊人、招贴广告。既占空间让人厌烦，又没人会搭理，于人于己都无利。
本文章名称：
本文章地址：316781314202125271234567891011
随笔 - 3930
文章 - 404
评论 - 122
留言簿(41)
阅读排行榜
评论排行榜
60天内阅读排行Linux下的XAMPP基本配置技巧 | 爱工作爱生活Linux上XAMPP装完之后，Navicat无法连下数据库的有关问题的解决_Llinux中mysql数据单向&双向同步札记_spring经典注脚实例二 10分钟弄懂__脚本百事通
稍等，加载中……
^_^请注意，有可能下面的2篇文章才是您想要的内容：
Linux上XAMPP装完之后，Navicat无法连下数据库的有关问题的解决
Llinux中mysql数据单向&双向同步札记
spring经典注脚实例二 10分钟弄懂
Linux上XAMPP装完之后，Navicat无法连下数据库的有关问题的解决
Linux下XAMPP装完之后，Navicat无法连上数据库的问题的解决Linux下装完XAMPP之后，mysql是自带装好了的，这个时候，mysql的root用户没有密码。
首先进入mysql，输入命令：mysql -uroot -p。输入密码时直接回车。
设置密码：set password =password('123456');
设置完密码之后，用本地的Navicat连接这个mysql，发现连不上，而且出现一个很奇怪的现象，弹出框显示，另一个ip下的root用户被拒绝访问！
原来是因为root没有被赋予足够的权限！执行这段命令即可： GRANT ALL PRIVILEGES ON *.* TO ‘root'@'%' IDENTIFIED BY 'mypassword' WITH GRANT OPTION;执行完之后，别忘了重启mysql。这时候，Navicat客户端可以轻松的连接上mysql数据库了
Llinux中mysql数据单向&双向同步札记
Llinux中mysql数据单向&双向同步笔记
最近因项目要求，在linux服务器上设置mysql的数据同步，幸好网络资源多啊，google一下全有了，不过实际操作起来，就麻烦了，遇到很多问题，不过多google一下也解决了，同时学习了很多相关方面的知识，现将总结于此，以备后用，希望对有此需要的JE们有所帮助；一、准备环境
自己做练习硬件资源少，只能在虚拟器上操作了哈哈！
linux 版本：Red Hat Enterprise Linux Server release 5.1
mysql 版本：MySQL-server-community-5.0.67-0.rhel5.i386.rpm
MySQL-client-community-5.0.67-0.rhel5.i386.rpm
（PS:mysql的同步机制是基于二进制日志binlog，不同的mysql版本会导致其格式的不同，从而导致不能实现数据同步，因此最好的搭配组合是Master的MySQL版本和Slave的版本相同或者Slave的版本高于Master的版本，因为mysql是向下兼容的，为此Master的版本不能高于Slave版本，否则有可能不能实现功能；如果要实现双向同步，最好mysql是同一版本）
虚拟机版本：VMware6.0
在虚拟机上安装两个linux系统，并分别安装上mysql（mysql安装在俺博客的mysql安装有详细说明）
mysql默认安装的文件分别为：
/var/lib/mysql/ （数据库目录，其所创建的数据库文件都在该目录下） /usr/share/mysql （mysql相关配置文件） /usr/bin （mysql相关命令，如mysql mysqladmin等）
为了区分系统，给系统命名一下，便于后面的说名：
LinuxA 系统： Ip：192.168.59.123 （Master）
LinuxB 系统： Ip：192.168.59.124 （Slave）
关闭LinuxA 和 LinuxB 的防火墙 #service iptables stop （保证系统互相可以ping的通）
二、设置单向mysql数据同步（LinuxA(Master)-&LinuxB(Slave)）
1、 LinuxA 为 master
LinuxB 为 slave （同步LinuxA 上mysql上指定的test数据库中的数据）；
由于刚安装的mysql，因此分别在LinuxA 和 LinuxB 的 mysql 上创建相同的数据库如 test（表有 stu ， class，teacher），保证两个mysql上的数据库名一致其表名及表的结构一致，若有一个不同，将导致无法实现同步；
（PS: 要使数据同步，必须保证数据库名一致其表名及表的结构一致）
2、在作为master（即LinuxA）的mysql上建立一个账户专门用于slave（即LinuxB）来进行数据同步
# mysql （默认用户，如设置了root密码，使用mysql -u root -p 登入mysql）
mysql&grant file on *.* to backa@'192.168.59.124' identified by 'backa'
（PS：此backa账户只能通过ip为192.168.59.124的访问）
在LinuxB上测试账户backa是否可以访问LinxuA上的mysql：
#mysql -u backa -p -h 192.168.59.123（输入密码backa，可以访问说明设置正确）
3、修改 my.cnf 文件
由于刚安装的mysql ，在/etc目录下可能无my.cnf文件，从/user/share/mysql目录中拷贝f 到/etc并修改成my.cnf （LinuxA 和LinuxB 上一样）
如 # cp /user/share/mysql/f
修改在LinuxA(Master)上的/f
log-bin=mysql-bin （日志文件，默认存在/var/lib/mysql下日志文件以mysql-bin为开头）
#log_bin= /var/log/mysql/mysql-bin.log（也可以自己指定，在此用# 表示注释掉了）
binlog-do-db =test（需要同步的数据库名，如需同步多个数据库，可以另起行如binlog-do-db =test1 ）
server-id= 1 （mysql标示）
修改完后保存退出，并重启mysql 如#service mysql restart （重启正常，表示配置没错误）
修改在LinxuB(Slave)上的/f
server-id= 2 （mysql标示，唯一否则启动会出错误）
master-host=192.168.59.123 （同步Master的ip地址）
master-user=backa （同步所需的账号）
master-password=backa （同步账号的密码）
master-port=3306 （LinuxA 中mysql的访问端口）
replicate-do-db=test （所需同步的数据库名，如果是同步多个数据库，可以另起一行如 replicate-do-db=test1）
#replicate-do-table=test.stu （如果只需同步test数据库中的stu表）
#replicate-do-table=test.teacher（如果只需同步test数据库中的stu表）
master-connect-retry=60 （主服务器（Master）宕机或连接丢失的情况下，从服务器（slave）线程重新尝试连接主服务器之前睡眠的秒数）
修改完后保存退出，并重启mysql 如#service mysql restart （重启正常，表示配置没错误）
4.启动同步
进到LinuxA（Master）的mysql上：
mysql&show master status\G (查看master当前状态)
运行完以上命令显示结果如下：
File: mysql-bin.000001 （当前binlog日志文件）
Position: 98 （但前binlog日志文件位置）
Binlog_Do_DB: test （同步数据库）Binlog_Ignore_DB:
（不需同步的数据，当前为设置）-------------------------
进到LinuxB（Slave）的mysql上：
mysql&show slave status\G (查看slave同步状态)
运行完以上命令显示结果如下：
Slave_IO_State: Waiting for master to send event （slave 的io线程，获取master的binlog的日志内容，该为其目前的状态）
Master_Host: 192.168.59.123 （所需同步Master的ip地址）
Master_User: backa（同步所需的账号）
Master_Port: 3306（同步所需的mysql端口号）
Connect_Retry: 60
Master_Log_File: mysql-bin.000001 （master中的binlong的日志文件，如与master的日志文件名不同则同步失效）
Read_Master_Log_Pos: 98 （master中的binlong的日志文件的位置，即mysql-bin.000001文件中的第98位置开始同步，若与master上的位置不同则同步失效）
Relay_Log_File: localhost-relay-bin.000001
Relay_Log_Pos: 235
Relay_Master_Log_File: mysql-bin.000001
Slave_IO_Running: Yes
（Slave的io线程是否运行）
Slave_SQL_Running: Yes （slave的sql线程是否运行，需要io线程和sql线程同为yes才有效）
Replicate_Do_DB: test
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Master_Log_Pos: 98
Relay_Log_Space: 235
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: No
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Master_SSL_Key:
Seconds_Behind_Master: 0
如果Slave_IO_State：不为 Waiting for master to send event 表示未现实同步
原因可能很多先列举自己遇到：
1、 Master_Log_File: mysql-bin.000001
Read_Master_Log_Pos:98
日志文件和位置与LinuxA（Master）的当前状态不一致
解决方式：（在LinuxB的mysql操作）
mysql&(修改前先关闭slave)
mysql&change master to
&master_log_file='mysql-bin.000001'
(ps:与LinuxA中的master的日志文件名相同)
&master_log_pso=98 (ps:与LinuxA中的master的日志文件当前位置相同)
&master_user='backa'
(如果同步的账户不一致，也可在此修改)
&master_password='backa'
(如果同步的账户密码不一致，也可在此修改)
(PS:如果重新修改/f 中相关slave的配置信息，重新启动查看 slave的状态还是显示未修改的数据，应为第一次是读取my.cnf，之后就会在/var/lib/mysql/下生成一个 的文件，因此第二次就不会读取my.cnf的内容，而是读取中的内容，为此要想使重新修改的my.cnf生效的话，删除文件，重起mysql即可)
mysql&(重新启动slave)
mysql&show slave status\G (查看slave状态)
如果显示的 Slave_IO_State: Waiting for master to send event
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
祝贺成功实现单向同步即 linuxA --& linuxB 的同步；
在LinuxA的mysql上对test的 insert ， delete ，update及对表结构的修改等操作 都会同步到 LinuxB的mysql上的test数据库上
（ps：如果在master上执行如 insert into to stu (uuid(),'yushan') 则同步到 slave上 ，id不同，因为其id是用uuid生成的，所以会不一致，之后对这条数据的delete 和 update则不会实现同步）三、双向同步（LinuxA&---&LinuxB）
双向同步最好使用的mysql版本要一致，保证二进制日志binlog的格式相同；双向同步即对任何一方mysql的insert，update，delete，alter等操作都会影响到另一方mysql中的数据；由于前面已成功设置单向同步，在此基础上，把LinuxB（Slave）的配置 添加到 LinuxA(Master) 上，把LinuxA（Master）的配置添加到LinuxB（Slave）上，然后启动设置同步的binlong文件及当前位置即可,具体操作如下：
1、 LinuxA 在原有Master的基础上增加Slave （同步LinuxB 上mysql上指定的test数据库中的数据）
LinuxB 在原有Slave的基础上增加Mmaster（同步LinuxA 上mysql上指定的test数据库中的数据）；
2、在作为master（即LinuxB）的mysql上建立一个账户专门用于slave（即LinuxA）来进行数据同步
# mysql （默认用户，如设置了root密码，使用mysql -u root -p 登入mysql）
mysql&grant file on *.* to backb@'192.168.59.123' identified by 'backb'
（PS：此backb账户只能通过ip为192.168.59.123的访问）
在LinuxA上测试账户backb是否可以访问LinxuB上的mysql：
#mysql -u backb -p -h 192.168.59.124（输入密码backb，可以访问说明设置正确）
3、修改 my.cnf 文件
在LinuxA 上的/f 文件上添加Slave的配置
#server-id= 2 （mysql标示，唯一否则启动会出错误，因为原先已有标示为1，在此就可以注释掉，一个mysql只需一个标示即可）
master-host=192.168.59.124 （同步LinuxB (Master)的ip地址）
master-user=backb （同步所需的账号）
master-password=backb （同步账号的密码）
master-port=3306 （LinuxB 中mysql的访问端口）
replicate-do-db=test （所需同步的数据库名，如果是同步多个数据库，可以另起一行如 replicate-do-db=test1）
#replicate-do-table=test.stu （如果只需同步test数据库中的stu表）
#replicate-do-table=test.teacher（如果只需同步test数据库中的stu表）
master-connect-retry=60 （主服务器（Master）宕机或连接丢失的情况下，从服务器（slave）线程重新尝试连接主服务器之前睡眠的秒数）
修改完后保存退出，并重启mysql 如#service mysql restart （重启正常，表示配置没错误）
在LinxuB上的/f文件上添加Master的配置
#server-id= 1 （mysql标示,唯一否则启动会出错误，因为原先已有标示为2，在此就可以注释掉，一个mysql只需一个标示即可）
log-bin=mysql-bin （日志文件，默认存在/var/lib/mysql下日志文件以mysql-bin为开头）
#log_bin= /var/log/mysql/mysql-bin.log（也可以自己指定，在此用# 表示注释掉了）
binlog-do-db =test（需要同步的数据库名，如需同步多个数据库，可以另起行如binlog-do-db =test1 ）
修改完后保存退出，并重启mysql 如#service mysql restart （重启正常，表示配置没错误）
4.启动同步
进到LinuxB（Master）的mysql上：
mysql&show master status\G (查看master当前状态)
运行完以上命令显示结果如下：
File: mysql-bin.000003 （当前binlog日志文件）
Position: 231 （但前binlog日志文件位置）
Binlog_Do_DB: test （同步数据库）Binlog_Ignore_DB:
（不需同步的数据，当前为设置） -------------------------
进到LinuxA（Slave）的mysql上：
mysql&show slave status\G (查看slave同步状态)
运行完以上命令显示结果如下：
Slave_IO_State: Waiting for master to send event （slave 的io线程，获取master的binlog的日志内容，该为其目前的状态）
Master_Host: 192.168.59.124 （所需同步Master的ip地址）
Master_User: backb（同步所需的账号）
Master_Port: 3306（同步所需的mysql端口号）
Connect_Retry: 60
Master_Log_File: mysql-bin.000003 （master中的binlong的日志文件，如与master的日志文件名不同则同步失效）
Read_Master_Log_Pos: 98 （master中的binlong的日志文件的位置，即mysql-bin.000001文件中的第98位置开始同步，若与master上的位置不同则同步失效）
Relay_Log_File: localhost-relay-bin.000001
Relay_Log_Pos: 231
Relay_Master_Log_File: mysql-bin.000001
Slave_IO_Running: Yes
（Slave的io线程是否运行）
Slave_SQL_Running: Yes （slave的sql线程是否运行，需要io线程和sql线程同为yes才有效）
Replicate_Do_DB: test
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Master_Log_Pos: 98
Relay_Log_Space: 235
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: No
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Master_SSL_Key:
Seconds_Behind_Master: 0
以上显示为正确同步 如果显示的一下数据不是
Slave_IO_State: Waiting for master to send event
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
若与以上的三个状态表示不同，则未实现同步；可以采用以上单向同步中的 change master 进行重新设置（ps：防火墙需关闭）
以上都能正确配置完且显示的状态一致，那么祝贺您成功实现双向同步即 linuxA &--& linuxB 的同步；
四、 mysql 数据同步相关说明（转载于网络，google一下很多） 1. 同步机制实现概述 MySQL同步机制基于master把所有对数据库的更新操作(更新、删除 等)都记录在二进制日志里。因此，想要启用同步机制，在master就必须启用二进制日志。 每个slave接受来自master上在二进制日志中记录的更新操作，因此在slave上执行了这个操作的一个拷贝。应该非常重要地意识到，二进制日志只是从启用二进制日志开始的时刻才记录更新操作的。所有的slave必须在启用二进制日志时把master上已经存在的数据拷贝过来。如果运行同步时slave上的数据和master上启用二进制日志时的数据不一致的话，那么slave同步就会失败。 2. 同步实现细节 MySQL同步功能由3个线程(master上1个，slave上2个)来实现。执行 START SLAVE 语句后，slave就创建一个I/O线程。I/O线程连接到master上，并请求master发送二进制日志中的语句。master创建一个线程来把日志的内容发送到slave上。这个线程在master上执行 SHOW PROCESSLIST 语句后的结果中的 Binlog Dump 线程便是。slave上的I/O线程读取master的 Binlog Dump 线程发送的语句，并且把它们拷贝到其数据目录下的中继日志(relay logs)中。第三个是SQL线程，salve用它来读取中继日志，然后执行它们来更新数据。 如上所述，每个mster/slave上都有3个线程。每个master上有多个线程，它为每个slave连接都创建一个线程，每个slave只有I/O和SQL线程。 在MySQL 4.0.2以前，同步只需2个线程(master和slave各一个)。slave上的I/O和SQL线程合并成一个了，它不使用中继日志。 slave上使用2个线程的优点是，把读日志和执行分开成2个独立的任务。执行任务如果慢的话，读日志任务不会跟着慢下来。例如，如果 slave停止了一段时间，那么I/O线程可以在slave启动后很快地从master上读取全部日志，尽管SQL线程可能落后I/O线程好几的小时。如果slave在SQL线程没全部执行完就停止了，不过I/O线程却已经把所有的更新日志都读取并且保存在本地的中继日志中了，因此在slave再次启动后就会继续执行它们了。这就允许在master上清除二进制日志，因为slave已经无需去master读取更新日志了。 在mysql中执行 SHOW PROCESSLIST 语句就会告诉我们所关心的master和slave上发生的情况 在master上，SHOW PROCESSLIST 的结果如下： mysql& SHOW PROCESSLIST\G *************************** 1. row *************************** Id: 21 User: root Host: localhost db: mysql Command: Query Time: 0 State: NULL Info: SHOW PROCESSLIST *************************** 2. row (MASTER线程)*************************** Id: 25 User: back Host: 192.168.1.125:34085 db: NULL Command: Binlog Dump Time: 746 State: Has sent waiting for binlog to be updated Info: NULL 2 rows in set (0.01 sec) 在这里，线程2是为一个slave连接创建的。结果表明所有未完成的更新日志已经都发送到slave了，master正等待新的更新日志发生。 在slave上，SHOW PROCESSLIST 的结果如下： mysql& SHOW PROCESSLIST\G *************************** 1. row *************************** Id: 2 User: system user Host: db: NULL Command: Connect Time: 70479 State: Waiting for master to send event Info: NULL *************************** 2. row (I/O线程) *************************** Id: 3 User: system user Host: db: NULL Command: Connect Time: 16971 State: Ha waiting for the slave I/O thread to update it Info: NULL *************************** 3. row (SQL线程)*************************** Id: 8 User: root Host: localhost db: NULL Command: Query Time: 0 State: NULL Info: SHOW PROCESSLIST 3 rows in set (0.00 sec) 这表明线程2是I/O线程，它正连接到master上；线程3是SQL线程，它执行中继日志中的更新操作。现在，这2个线程都处于空闲状态，正等待新的更新日志。 注意，Time 字段的值告诉我们slave上的日志比master晚了多久。 3. Master 同步线程状态 以下列出了master的 Binlog Dump 线程 State 字段中最常见的几种状态。如果在master上没有 Binlog Dump 线程，那么同步就没有在运行。也就是说，没有slave连接上来。 Sending binlog event to slave 事件是由二进制日志构成，一个事件通常由更新语句加上其他信息。线程读取到一个事件并正发送到slave上。 Finishe switching to next binlog 读取完了一个二进制日志，正切换到下一个。 Has sent waiting for binlog to be updated 已经读取完全部未完成更新日志，并且全部都发送到slave了。它处于空闲状态，正等待在master上执行新的更新操作以在二进制日志中产生新的事件，然后读取它们。 Waiting to finalize termination 当前线程停止了，这个时间很短 4. Slave的I/O线程状态 以下列出了slave的I/O线程 State 字段中最常见的几种状态。从MySQL 4.1.1开始，这个状态在执行 SHOW SLAVE STATUS 语句结果的 Slave_IO_State 字段也会出现。这意味着可以只执行 SHOW SLAVE STATUS 语句就能了解到更多的信息。 Connecting to master 该线程证尝试连接到master上。 Checking master version 确定连接到master后出现的一个短暂的状态。 Registering slave on master 确定连接到master后出现的一个短暂的状态。 Requesting binlog dump 确定连接到master后出现的一个短暂的状态。该线程向master发送一个请求，告诉它要请求的二进制文件以及开始位置。 Waiting to reconnect after a failed binlog dump request 如果二进制日志转储(binary log dump)请求失败了(由于连接断开)，该线程在休眠时进入这个状态，并定期重连。重连的时间间隔由 --master-connect-retry 选项来指定。 Reconnecting after a failed binlog dump request 该线程正尝试重连到master。 Waiting for master to send event 已经连接到master，正等待它发送二进制日志。如果master闲置时，这个状态可能会持续较长时间，如果它等待超过 slave_read_timeout 秒，就会发生超时。这时，它就会考虑断开连接，然后尝试重连。 Queueing master event to the relay log 已经读取到一个事件，正把它拷贝到中继日志中以备SQL线程处理。 Waiting to reconnect after a failed master event read 读日志时发生错误(由于连接断开)。该线程在重连之前休眠 master-connect-retry 秒。 Reconnecting after a failed master event read 正尝试重连到master。当连接确定后，状态就变成 Waiting for master to send event。 Waiting for the slave SQL thread to free enough relay log space relay_log_space_limit 的值非零，中继日志的大小总和超过这个值了。I/O线程等待SQL线程先处理中继日志然后删除它们以释放足够的空间。 Waiting for slave mutex on exit 当前线程停止了，这个时间很短。 5. Slave的SQL线程状态 以下列出了slave的SQL线程 State 字段中最常见的几种状态： Reading event from the relay log 从中继日志里读到一个事件以备执行。 Ha waiting for the slave I/O thread to update it 已经处理完中继日志中的全部事件了，正等待I/O线程写入更新的日志。 Waiting for slave mutex on exit 当前线程停止了，这个时间很短。 SQL线程的 State 字段有时候也可能是一个SQL语句。这意味着它从中继日志中读取到一个事件了，从中提取出SQL语句，并执行它。
（自己画的mysql同步原理图）
相关mysql数据同步资料的连接：
http://deidara./039
/tech/database//65.html
scn.org/htm_data/288/.html
http://www.koven.org/archives/203.html
/harryguo/archive//1099223.html
http://www.blogjava.net/lzj520/archive//182485.html
spring经典注脚实例二 10分钟弄懂
spring经典注解实例二 10分钟弄懂
昨天对Spring注解有了一个整体认识，至少完成了一个简单的web应用搭建。当然，还不完善，这仅仅只是个开始！ 今天看了Spring 3.0的注解，我感觉自己被颠覆了。多年前，为了减少代码依赖我们用配置文件进行模块间耦合，降低模块之间的黏度。现如今，所有可配置的内容都塞进了代码中，我只能说：这多少有点顾此失彼，有点倒退的意思！使用注解的好处是：代码通读性增强。这既是优势也是劣势！如果我要改一段配置，就要打开代码逐行扫描；如果恰巧这是别人封装的jar包，那我只好反编译；如果碰巧遇上这个jar包经过了混淆，那我只好求助于AOP了。 为了这么一个配置，我的代码观几乎将要被颠覆！言归正传，研究一下注解下的控制层。 我习惯于使用JSTL展示页面，因此需要在原lib基础上增加jstl.jar和standard.jar，详细lib依赖如下：引用aopalliance-1.0.jar commons-logging-1.1.1.jar log4j-1.2.15.jar spring-beans-2.5.6.jar spring-context-2.5.6.jar spring-context-support-2.5.6.jar spring-core-2.5.6.jar spring-tx-2.5.6.jar spring-web-2.5.6.jar spring-webmvc-2.5.6.jar standard.jar jstl.jar 上一篇文中，我们定义了控制器AccountController： AccountController.javaJava代码
4.package org.zlex.spring.
6.import javax.servlet.http.HttpServletR
7.import javax.servlet.http.HttpServletR
9.import org.springframework.beans.factory.annotation.A
10.import org.springframework.stereotype.C
11.import org.springframework.web.bind.ServletRequestU
12.import org.springframework.web.bind.annotation.RequestM
13.import org.springframework.web.bind.annotation.RequestM
14.import org.zlex.spring.service.AccountS
18. * @author &a href="mailto:zlex."&梁栋&/a&
19. * @version 1.0
20. * @since 1.0
22.@Controller
23.@RequestMapping("/account.do")
24.public class AccountController {
@Autowired
private AccountService accountS
@RequestMapping(method = RequestMethod.GET)
public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password));
Java代码 1./**
4.package org.zlex.spring.
6.import javax.servlet.http.HttpServletR
7.import javax.servlet.http.HttpServletR
9.import org.springframework.beans.factory.annotation.A
10.import org.springframework.stereotype.C
11.import org.springframework.web.bind.ServletRequestU
12.import org.springframework.web.bind.annotation.RequestM
13.import org.springframework.web.bind.annotation.RequestM
14.import org.zlex.spring.service.AccountS
18. * @author &a href="mailto:zlex."&梁栋&/a&
19. * @version 1.0
20. * @since 1.0
22.@Controller
23.@RequestMapping("/account.do")
24.public class AccountController {
@Autowired
private AccountService accountS
@RequestMapping(method = RequestMethod.GET)
public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password));
*/package org.zlex.spring.import javax.servlet.http.HttpServletRimport javax.servlet.http.HttpServletRimport org.springframework.beans.factory.annotation.Aimport org.springframework.stereotype.Cimport org.springframework.web.bind.ServletRequestUimport org.springframework.web.bind.annotation.RequestMimport org.springframework.web.bind.annotation.RequestMimport org.zlex.spring.service.AccountS/** *
* @author &a href="mailto:zlex."&梁栋&/a& * @version 1.0 * @since 1.0 */@Controller@RequestMapping("/account.do")public class AccountController { @Autowired private AccountService accountS @RequestMapping(method = RequestMethod.GET) public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password)); }}先说注解@RequestMapping 这里使用注解@RequestMapping(method = RequestMethod.GET)指定这个方法为get请求时调用。同样，我们可以使用注解@RequestMapping(method = RequestMethod.POST)指定该方法接受post请求。Java代码
1.@Controller
2.@RequestMapping("/account.do")
3.public class AccountController {
@RequestMapping(method = RequestMethod.GET)
public void get() {
@RequestMapping(method = RequestMethod.POST)
public void post() {
Java代码 1.@Controller
2.@RequestMapping("/account.do")
3.public class AccountController {
@RequestMapping(method = RequestMethod.GET)
public void get() {
@RequestMapping(method = RequestMethod.POST)
public void post() {
@Controller@RequestMapping("/account.do")public class AccountController { @RequestMapping(method = RequestMethod.GET) public void get() { } @RequestMapping(method = RequestMethod.POST) public void post() { }}这与我们久别的Servlet很相像，类似于doGet()和doPost()方法！ 我们也可以将其改造为多动作控制器，如下代码所示：Java代码
1.@Controller
2.@RequestMapping("/account.do")
3.public class AccountController {
@RequestMapping(params = "method=login")
public void login() {
@RequestMapping(params = "method=logout")
public void logout() {
Java代码 1.@Controller
2.@RequestMapping("/account.do")
3.public class AccountController {
@RequestMapping(params = "method=login")
public void login() {
@RequestMapping(params = "method=logout")
public void logout() {
@Controller@RequestMapping("/account.do")public class AccountController { @RequestMapping(params = "method=login")
public void login() { } @RequestMapping(params = "method=logout")
public void logout() { }这样，我们可以通过参数“method”指定不同的参数值从而通过请求（"/account.do?method=login"和"/account.do?method=logout"）调用不同的方法！注意：使用多动作控制器必须在配置文件中加入注解支持！Xml代码
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&
Xml代码 1.&bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&当然，我们也可以将注解@RequestMapping指定到某一个方法上，如：Java代码
1.@Controller
2.public class AccountController {
@RequestMapping("/a.do")
public void a() {}
@RequestMapping("/b.do")
public void b() {}
Java代码 1.@Controller
2.public class AccountController {
@RequestMapping("/a.do")
public void a() {}
@RequestMapping("/b.do")
public void b() {}
@Controllerpublic class AccountController { @RequestMapping("/a.do") public void a() {} @RequestMapping("/b.do") public void b() {}}这样，请求“a.do”和“b.do”将对应不同的方法a() 和b()。这使得一个控制器可以同时承载多个请求！ @RequestMapping("/account.do")是@RequestMapping(value="/account.do")的简写！ 再说输入参数！ 这里的方法名可以随意定义，但是参数和返回值却又要求！ 为什么？直接看源代码，我们就能找到答案！AnnotationMethodHandlerAdapter.java部分源代码——有关参数部分：Java代码
1.@Override
2.protected Object resolveStandardArgument(Class parameterType, NativeWebRequest webRequest)
throws Exception {
HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
HttpServletResponse response = (HttpServletResponse) webRequest.getNativeResponse();
if (ServletRequest.class.isAssignableFrom(parameterType)) {
else if (ServletResponse.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
else if (HttpSession.class.isAssignableFrom(parameterType)) {
return request.getSession();
else if (Principal.class.isAssignableFrom(parameterType)) {
return request.getUserPrincipal();
else if (Locale.class.equals(parameterType)) {
return RequestContextUtils.getLocale(request);
else if (InputStream.class.isAssignableFrom(parameterType)) {
return request.getInputStream();
else if (Reader.class.isAssignableFrom(parameterType)) {
return request.getReader();
else if (OutputStream.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getOutputStream();
else if (Writer.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getWriter();
return super.resolveStandardArgument(parameterType, webRequest);
Java代码 1.@Override
2.protected Object resolveStandardArgument(Class parameterType, NativeWebRequest webRequest)
throws Exception {
HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
HttpServletResponse response = (HttpServletResponse) webRequest.getNativeResponse();
if (ServletRequest.class.isAssignableFrom(parameterType)) {
else if (ServletResponse.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
else if (HttpSession.class.isAssignableFrom(parameterType)) {
return request.getSession();
else if (Principal.class.isAssignableFrom(parameterType)) {
return request.getUserPrincipal();
else if (Locale.class.equals(parameterType)) {
return RequestContextUtils.getLocale(request);
else if (InputStream.class.isAssignableFrom(parameterType)) {
return request.getInputStream();
else if (Reader.class.isAssignableFrom(parameterType)) {
return request.getReader();
else if (OutputStream.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getOutputStream();
else if (Writer.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getWriter();
return super.resolveStandardArgument(parameterType, webRequest);
protected Object resolveStandardArgument(Class parameterType, NativeWebRequest webRequest)
throws Exception {
HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
HttpServletResponse response = (HttpServletResponse) webRequest.getNativeResponse();
if (ServletRequest.class.isAssignableFrom(parameterType)) {
else if (ServletResponse.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
else if (HttpSession.class.isAssignableFrom(parameterType)) {
return request.getSession();
else if (Principal.class.isAssignableFrom(parameterType)) {
return request.getUserPrincipal();
else if (Locale.class.equals(parameterType)) {
return RequestContextUtils.getLocale(request);
else if (InputStream.class.isAssignableFrom(parameterType)) {
return request.getInputStream();
else if (Reader.class.isAssignableFrom(parameterType)) {
return request.getReader();
else if (OutputStream.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getOutputStream();
else if (Writer.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getWriter();
return super.resolveStandardArgument(parameterType, webRequest);
}也就是说，如果我们想要在自定义的方法中获得一些个“标准”输入参数，参数类型必须包含在以下类型中：引用ServletRequest ServletResponse HttpSession Principal Locale InputStream OutputStream Reader Writer 当然，上述接口其实都是对于HttpServletRequest和HttpServletResponse的扩展。 此外，我们还可以定义自己的参数。 注意：自定义参数必须是实现类，绝非接口！Spring容器将帮你完成对象初始化工作！ 比如说上文中，我们需要参数username和password。我们可以这么写：Java代码
1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(String username,String password) {
System.out.println(accountService.verify(username, password));
Java代码 1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(String username,String password) {
System.out.println(accountService.verify(username, password));
@RequestMapping(method = RequestMethod.GET) public void hello(String username,String password) {
System.out.println(accountService.verify(username, password)); }如果参数名不能与这里的变量名保持一致，那么我们可以使用注解@RequestParam进行强制绑定，代码如下所示：Java代码
1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(@RequestParam("username") String u,
@RequestParam("password") String p) {
System.out.println(accountService.verify(u, p));
Java代码 1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(@RequestParam("username") String u,
@RequestParam("password") String p) {
System.out.println(accountService.verify(u, p));
@RequestMapping(method = RequestMethod.GET) public void hello(@RequestParam("username") String u,
@RequestParam("password") String p) {
System.out.println(accountService.verify(u, p)); }这比起我们之前写的代码有所简洁：Java代码
1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password));
Java代码 1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password));
@RequestMapping(method = RequestMethod.GET) public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password)); }ServletRequestUtils类的工作已经由Spring底层实现了，我们只需要把参数名定义一致即可，其内部取参无需关心！除了传入参数，我们还可以定义即将传出的参数，如加入ModelMap参数：Java代码
1.@SuppressWarnings("unchecked")
2.@RequestMapping(method = RequestMethod.GET)
3.public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
Java代码 1.@SuppressWarnings("unchecked")
2.@RequestMapping(method = RequestMethod.GET)
3.public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
@SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
}这时，我们没有定义页面名称，Spring容器将根据请求名指定同名view，即如果是jap页面，则account.do-&account.jsp！ 不得不承认，这样写起来的确减少了代码量！接着说输出参数！ 通过ModelMap，我们可以绑定输出到的页面的参数，但最终我们将要返回到何种页面呢？再次查看AnnotationMethodHandlerAdapter源代码！ AnnotationMethodHandlerAdapter.java部分源代码——有关返回值部分：Java代码
1.@SuppressWarnings("unchecked")
2.public ModelAndView getModelAndView(Method handlerMethod, Class handlerType, Object returnValue,
ExtendedModelMap implicitModel, ServletWebRequest webRequest) {
if (returnValue instanceof ModelAndView) {
ModelAndView mav = (ModelAndView) returnV
mav.getModelMap().mergeAttributes(implicitModel);
else if (returnValue instanceof Model) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects(((Model) returnValue).asMap());
else if (returnValue instanceof Map) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects((Map) returnValue);
else if (returnValue instanceof View) {
return new ModelAndView((View) returnValue).addAllObjects(implicitModel);
else if (returnValue instanceof String) {
return new ModelAndView((String) returnValue).addAllObjects(implicitModel);
else if (returnValue == null) {
// Either returned null or was 'void' return.
if (this.responseArgumentUsed || webRequest.isNotModified()) {
// Assuming view name translation...
return new ModelAndView().addAllObjects(implicitModel);
else if (!BeanUtils.isSimpleProperty(returnValue.getClass())) {
// Assume a single model attribute...
ModelAttribute attr = AnnotationUtils.findAnnotation(handlerMethod, ModelAttribute.class);
String attrName = (attr != null ? attr.value() : "");
ModelAndView mav = new ModelAndView().addAllObjects(implicitModel);
if ("".equals(attrName)) {
Class resolvedType = GenericTypeResolver.resolveReturnType(handlerMethod, handlerType);
attrName = Conventions.getVariableNameForReturnType(handlerMethod, resolvedType, returnValue);
return mav.addObject(attrName, returnValue);
throw new IllegalArgumentException("Invalid handler method return value: " + returnValue);
Java代码 1.@SuppressWarnings("unchecked")
2.public ModelAndView getModelAndView(Method handlerMethod, Class handlerType, Object returnValue,
ExtendedModelMap implicitModel, ServletWebRequest webRequest) {
if (returnValue instanceof ModelAndView) {
ModelAndView mav = (ModelAndView) returnV
mav.getModelMap().mergeAttributes(implicitModel);
else if (returnValue instanceof Model) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects(((Model) returnValue).asMap());
else if (returnValue instanceof Map) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects((Map) returnValue);
else if (returnValue instanceof View) {
return new ModelAndView((View) returnValue).addAllObjects(implicitModel);
else if (returnValue instanceof String) {
return new ModelAndView((String) returnValue).addAllObjects(implicitModel);
else if (returnValue == null) {
// Either returned null or was 'void' return.
if (this.responseArgumentUsed || webRequest.isNotModified()) {
// Assuming view name translation...
return new ModelAndView().addAllObjects(implicitModel);
else if (!BeanUtils.isSimpleProperty(returnValue.getClass())) {
// Assume a single model attribute...
ModelAttribute attr = AnnotationUtils.findAnnotation(handlerMethod, ModelAttribute.class);
String attrName = (attr != null ? attr.value() : "");
ModelAndView mav = new ModelAndView().addAllObjects(implicitModel);
if ("".equals(attrName)) {
Class resolvedType = GenericTypeResolver.resolveReturnType(handlerMethod, handlerType);
attrName = Conventions.getVariableNameForReturnType(handlerMethod, resolvedType, returnValue);
return mav.addObject(attrName, returnValue);
throw new IllegalArgumentException("Invalid handler method return value: " + returnValue);
@SuppressWarnings("unchecked")
public ModelAndView getModelAndView(Method handlerMethod, Class handlerType, Object returnValue,
ExtendedModelMap implicitModel, ServletWebRequest webRequest) {
if (returnValue instanceof ModelAndView) {
ModelAndView mav = (ModelAndView) returnV
mav.getModelMap().mergeAttributes(implicitModel);
else if (returnValue instanceof Model) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects(((Model) returnValue).asMap());
else if (returnValue instanceof Map) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects((Map) returnValue);
else if (returnValue instanceof View) {
return new ModelAndView((View) returnValue).addAllObjects(implicitModel);
else if (returnValue instanceof String) {
return new ModelAndView((String) returnValue).addAllObjects(implicitModel);
else if (returnValue == null) {
// Either returned null or was 'void' return.
if (this.responseArgumentUsed || webRequest.isNotModified()) {
// Assuming view name translation...
return new ModelAndView().addAllObjects(implicitModel);
else if (!BeanUtils.isSimpleProperty(returnValue.getClass())) {
// Assume a single model attribute...
ModelAttribute attr = AnnotationUtils.findAnnotation(handlerMethod, ModelAttribute.class);
String attrName = (attr != null ? attr.value() : "");
ModelAndView mav = new ModelAndView().addAllObjects(implicitModel);
if ("".equals(attrName)) {
Class resolvedType = GenericTypeResolver.resolveReturnType(handlerMethod, handlerType);
attrName = Conventions.getVariableNameForReturnType(handlerMethod, resolvedType, returnValue);
return mav.addObject(attrName, returnValue);
throw new IllegalArgumentException("Invalid handler method return value: " + returnValue);
} }返回值的定义十分庞大，或者说可怕的if-else多少有点让我觉得厌恶！我们可以定义以下类型的返回值：引用ModelAndView Model View Map String null ModelAndView、Model和View都是Spring之前版本所特有的元素，Map对应于传入参数ModelMap，String定义页面名称，null即对应void类型方法！ 最常用的实现方式如下：Java代码
1.@SuppressWarnings("unchecked")
2.@RequestMapping(method = RequestMethod.GET)
3.public String hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
return "account";
Java代码 1.@SuppressWarnings("unchecked")
2.@RequestMapping(method = RequestMethod.GET)
3.public String hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
return "account";
@SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) public String hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
return "account"; }当然，对于我来说在返回值中写入这么一个字符串多少有点不能接受，于是我还是乐于使用输入参数ModelMap+输出参数Map的方式。 给出一个完整的AccountController实现： AccountController.javaJava代码
4.package org.zlex.spring.
6.import java.util.M
8.import org.springframework.beans.factory.annotation.A
9.import org.springframework.stereotype.C
10.import org.springframework.ui.ModelM
11.import org.springframework.web.bind.annotation.RequestM
12.import org.springframework.web.bind.annotation.RequestM
13.import org.zlex.spring.service.AccountS
17. * @author &a href="mailto:zlex."&梁栋&/a&
18. * @version 1.0
19. * @since 1.0
21.@Controller
22.@RequestMapping("/account.do")
23.public class AccountController {
@Autowired
private AccountService accountS
@SuppressWarnings("unchecked")
@RequestMapping(method = RequestMethod.GET)
public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
Java代码 1./**
4.package org.zlex.spring.
6.import java.util.M
8.import org.springframework.beans.factory.annotation.A
9.import org.springframework.stereotype.C
10.import org.springframework.ui.ModelM
11.import org.springframework.web.bind.annotation.RequestM
12.import org.springframework.web.bind.annotation.RequestM
13.import org.zlex.spring.service.AccountS
17. * @author &a href="mailto:zlex."&梁栋&/a&
18. * @version 1.0
19. * @since 1.0
21.@Controller
22.@RequestMapping("/account.do")
23.public class AccountController {
@Autowired
private AccountService accountS
@SuppressWarnings("unchecked")
@RequestMapping(method = RequestMethod.GET)
public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
*/package org.zlex.spring.import java.util.Mimport org.springframework.beans.factory.annotation.Aimport org.springframework.stereotype.Cimport org.springframework.ui.ModelMimport org.springframework.web.bind.annotation.RequestMimport org.springframework.web.bind.annotation.RequestMimport org.zlex.spring.service.AccountS/** *
* @author &a href="mailto:zlex."&梁栋&/a& * @version 1.0 * @since 1.0 */@Controller@RequestMapping("/account.do")public class AccountController { @Autowired private AccountService accountS @SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
}}最后说注解@Session 如果想将某个ModelMap中的参数指定到Session中，可以使用@Session注解，将其绑定为Session熟悉，代码如下所示：Java代码
1.@Controller
2.@RequestMapping("/account.do")
3.@SessionAttributes("msg")
4.public class AccountController {
@Autowired
private AccountService accountS
@SuppressWarnings("unchecked")
@RequestMapping(method = RequestMethod.GET)
public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
Java代码 1.@Controller
2.@RequestMapping("/account.do")
3.@SessionAttributes("msg")
4.public class AccountController {
@Autowired
private AccountService accountS
@SuppressWarnings("unchecked")
@RequestMapping(method = RequestMethod.GET)
public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
@Controller@RequestMapping("/account.do")@SessionAttributes("msg")public class AccountController { @Autowired private AccountService accountS @SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
}}当然，我们还需要配置一下对应的视图解析器，给出完整配置： servelt.xmlXml代码
1.&?xml version="1.0" encoding="UTF-8"?&
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
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"&
&context:component-scan
base-package="org.zlex.spring.controller" /&
id="urlMapping"
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /&
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&
id="jstlViewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:viewClass="org.springframework.web.servlet.view.JstlView"
p:prefix="/WEB-INF/page/"
p:suffix=".jsp" /&
22.&/beans&
Xml代码 1.&?xml version="1.0" encoding="UTF-8"?&
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
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"&
&context:component-scan
base-package="org.zlex.spring.controller" /&
id="urlMapping"
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /&
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&
id="jstlViewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:viewClass="org.springframework.web.servlet.view.JstlView"
p:prefix="/WEB-INF/page/"
p:suffix=".jsp" /&
22.&/beans&
&?xml version="1.0" encoding="UTF-8"?&&beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 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"& &context:component-scan
base-package="org.zlex.spring.controller" /& &bean
id="urlMapping"
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /& &bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /& &bean
id="jstlViewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:viewClass="org.springframework.web.servlet.view.JstlView"
p:prefix="/WEB-INF/page/"
p:suffix=".jsp" /&&/beans&这里使用了JstlView作为视图解析器。同时，指定前缀路径为"/WEB-INF/page/"，后缀路径为".jsp"。也就是说，Spring容器将会在这个路径中寻找匹配的jsp文件！ 注意加入xmlns:p="http://www.springframework.org/schema/p"命名空间！ 再给出页面内容： taglib.jspJsp代码
1.&%@ taglib prefix="c" uri="/jsp/jstl/core"%&
2.&%@ taglib prefix="fmt" uri="/jsp/jstl/fmt"%&
3.&%@ taglib prefix="sql" uri="/jsp/jstl/sql"%&
4.&%@ taglib prefix="x" uri="/jsp/jstl/xml"%&
5.&%@ taglib prefix="fn" uri="/jsp/jstl/functions"%&
6.&%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%&
7.&%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%&
Jsp代码 1.&%@ taglib prefix="c" uri="/jsp/jstl/core"%&
2.&%@ taglib prefix="fmt" uri="/jsp/jstl/fmt"%&
3.&%@ taglib prefix="sql" uri="/jsp/jstl/sql"%&
4.&%@ taglib prefix="x" uri="/jsp/jstl/xml"%&
5.&%@ taglib prefix="fn" uri="/jsp/jstl/functions"%&
6.&%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%&
7.&%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%&
&%@ taglib prefix="c" uri="/jsp/jstl/core"%&&%@ taglib prefix="fmt" uri="/jsp/jstl/fmt"%&&%@ taglib prefix="sql" uri="/jsp/jstl/sql"%&&%@ taglib prefix="x" uri="/jsp/jstl/xml"%&&%@ taglib prefix="fn" uri="/jsp/jstl/functions"%&&%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%&&%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%&account.japJsp代码
1.&%@ page language="java" contentType="text/ charset=UTF-8"
pageEncoding="UTF-8"%&
3.&%@ include file="/WEB-INF/page/taglib.jsp"%&
4.&!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"&
7.&meta http-equiv="Content-Type" content="text/ charset=UTF-8"&
8.&title&Account&/title&
11.&c:out value="${msg}"&&/c:out&
12.&/body&
13.&/html&
Jsp代码 1.&%@ page language="java" contentType="text/ charset=UTF-8"
pageEncoding="UTF-8"%&
3.&%@ include file="/WEB-INF/page/taglib.jsp"%&
4.&!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"&
7.&meta http-equiv="Content-Type" content="text/ charset=UTF-8"&
8.&title&Account&/title&
11.&c:out value="${msg}"&&/c:out&
12.&/body&
13.&/html&
&%@ page language="java" contentType="text/ charset=UTF-8" pageEncoding="UTF-8"%&&%@ include file="/WEB-INF/page/taglib.jsp"%&&!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"&&html&&head&&meta http-equiv="Content-Type" content="text/ charset=UTF-8"&&title&Account&/title&&/head&&body&&c:out value="${msg}"&&/c:out&&/body&&/html&目录结构如图所示： 启动应用，最后将得到一个带有内容的页面，如图： 代码见附件！
如果您想提高自己的技术水平，欢迎加入本站官方1号QQ群：&&，&&2号QQ群：，在群里结识技术精英和交流技术^_^
本站联系邮箱：}
当前位置： >
如何设置xampp的权限？
如何设置xampp的权限？
如何设置xampp的权限？相关软件推荐下载：
所属栏目：
如何设置xampp的权限？相信大家都知道，在xampp中的mysql等用户名权限和密码都空白的，那么就需要我们自己动手更改设置，那么要如何设置xampp的权限呢？下面就请大家跟着小编一起来看看怎么设置吧！
1.首先要打开；
2.运行红框中的程序；
3.打开任意在地址栏中输入http://localhost/，弹出页面，选择语言为中文；()
4.点击左边的&安全&；
5.此时我们的数据库显示是不安全的，点击如下图所示的链接：
6.在1中输入mysql的密码，点击2，然后在3中输入用户名和密码，点击4就可以了；
以上就是设置xampp权限的具体操作步骤了！还不会设置的朋友就赶紧去操作试试吧！
上一篇文章：
下一篇文章：
已有条评论，
(您的评论需要经过审核才能显示,请文明发言！)
07-0307-0207-0207-0207-0207-0207-0207-0207-0207-02
可能你喜欢的软件
感谢您为本站写下的评论，您的评论对其它用户来说具有重要的参考价值，所以请认真填写。
类似"顶"、"沙发"之类没有营养的文字，对勤劳贡献的楼主来说是令人沮丧的反馈信息。
相信您也不想看到一排文字/表情墙，所以请不要反馈意义不大的重复字符，也请尽量不要纯表情的回复。
提问之前请再仔细看一遍楼主的说明，或许是您遗漏了。
请勿到处挖坑绊人、招贴广告。既占空间让人厌烦，又没人会搭理，于人于己都无利。
本文章名称：
本文章地址：316781314202125271234567891011
随笔 - 3930
文章 - 404
评论 - 122
留言簿(41)
阅读排行榜
评论排行榜
60天内阅读排行Linux下的XAMPP基本配置技巧 | 爱工作爱生活Linux上XAMPP装完之后，Navicat无法连下数据库的有关问题的解决_Llinux中mysql数据单向&双向同步札记_spring经典注脚实例二 10分钟弄懂__脚本百事通
稍等，加载中……
^_^请注意，有可能下面的2篇文章才是您想要的内容：
Linux上XAMPP装完之后，Navicat无法连下数据库的有关问题的解决
Llinux中mysql数据单向&双向同步札记
spring经典注脚实例二 10分钟弄懂
Linux上XAMPP装完之后，Navicat无法连下数据库的有关问题的解决
Linux下XAMPP装完之后，Navicat无法连上数据库的问题的解决Linux下装完XAMPP之后，mysql是自带装好了的，这个时候，mysql的root用户没有密码。
首先进入mysql，输入命令：mysql -uroot -p。输入密码时直接回车。
设置密码：set password =password('123456');
设置完密码之后，用本地的Navicat连接这个mysql，发现连不上，而且出现一个很奇怪的现象，弹出框显示，另一个ip下的root用户被拒绝访问！
原来是因为root没有被赋予足够的权限！执行这段命令即可： GRANT ALL PRIVILEGES ON *.* TO ‘root'@'%' IDENTIFIED BY 'mypassword' WITH GRANT OPTION;执行完之后，别忘了重启mysql。这时候，Navicat客户端可以轻松的连接上mysql数据库了
Llinux中mysql数据单向&双向同步札记
Llinux中mysql数据单向&双向同步笔记
最近因项目要求，在linux服务器上设置mysql的数据同步，幸好网络资源多啊，google一下全有了，不过实际操作起来，就麻烦了，遇到很多问题，不过多google一下也解决了，同时学习了很多相关方面的知识，现将总结于此，以备后用，希望对有此需要的JE们有所帮助；一、准备环境
自己做练习硬件资源少，只能在虚拟器上操作了哈哈！
linux 版本：Red Hat Enterprise Linux Server release 5.1
mysql 版本：MySQL-server-community-5.0.67-0.rhel5.i386.rpm
MySQL-client-community-5.0.67-0.rhel5.i386.rpm
（PS:mysql的同步机制是基于二进制日志binlog，不同的mysql版本会导致其格式的不同，从而导致不能实现数据同步，因此最好的搭配组合是Master的MySQL版本和Slave的版本相同或者Slave的版本高于Master的版本，因为mysql是向下兼容的，为此Master的版本不能高于Slave版本，否则有可能不能实现功能；如果要实现双向同步，最好mysql是同一版本）
虚拟机版本：VMware6.0
在虚拟机上安装两个linux系统，并分别安装上mysql（mysql安装在俺博客的mysql安装有详细说明）
mysql默认安装的文件分别为：
/var/lib/mysql/ （数据库目录，其所创建的数据库文件都在该目录下） /usr/share/mysql （mysql相关配置文件） /usr/bin （mysql相关命令，如mysql mysqladmin等）
为了区分系统，给系统命名一下，便于后面的说名：
LinuxA 系统： Ip：192.168.59.123 （Master）
LinuxB 系统： Ip：192.168.59.124 （Slave）
关闭LinuxA 和 LinuxB 的防火墙 #service iptables stop （保证系统互相可以ping的通）
二、设置单向mysql数据同步（LinuxA(Master)-&LinuxB(Slave)）
1、 LinuxA 为 master
LinuxB 为 slave （同步LinuxA 上mysql上指定的test数据库中的数据）；
由于刚安装的mysql，因此分别在LinuxA 和 LinuxB 的 mysql 上创建相同的数据库如 test（表有 stu ， class，teacher），保证两个mysql上的数据库名一致其表名及表的结构一致，若有一个不同，将导致无法实现同步；
（PS: 要使数据同步，必须保证数据库名一致其表名及表的结构一致）
2、在作为master（即LinuxA）的mysql上建立一个账户专门用于slave（即LinuxB）来进行数据同步
# mysql （默认用户，如设置了root密码，使用mysql -u root -p 登入mysql）
mysql&grant file on *.* to backa@'192.168.59.124' identified by 'backa'
（PS：此backa账户只能通过ip为192.168.59.124的访问）
在LinuxB上测试账户backa是否可以访问LinxuA上的mysql：
#mysql -u backa -p -h 192.168.59.123（输入密码backa，可以访问说明设置正确）
3、修改 my.cnf 文件
由于刚安装的mysql ，在/etc目录下可能无my.cnf文件，从/user/share/mysql目录中拷贝f 到/etc并修改成my.cnf （LinuxA 和LinuxB 上一样）
如 # cp /user/share/mysql/f
修改在LinuxA(Master)上的/f
log-bin=mysql-bin （日志文件，默认存在/var/lib/mysql下日志文件以mysql-bin为开头）
#log_bin= /var/log/mysql/mysql-bin.log（也可以自己指定，在此用# 表示注释掉了）
binlog-do-db =test（需要同步的数据库名，如需同步多个数据库，可以另起行如binlog-do-db =test1 ）
server-id= 1 （mysql标示）
修改完后保存退出，并重启mysql 如#service mysql restart （重启正常，表示配置没错误）
修改在LinxuB(Slave)上的/f
server-id= 2 （mysql标示，唯一否则启动会出错误）
master-host=192.168.59.123 （同步Master的ip地址）
master-user=backa （同步所需的账号）
master-password=backa （同步账号的密码）
master-port=3306 （LinuxA 中mysql的访问端口）
replicate-do-db=test （所需同步的数据库名，如果是同步多个数据库，可以另起一行如 replicate-do-db=test1）
#replicate-do-table=test.stu （如果只需同步test数据库中的stu表）
#replicate-do-table=test.teacher（如果只需同步test数据库中的stu表）
master-connect-retry=60 （主服务器（Master）宕机或连接丢失的情况下，从服务器（slave）线程重新尝试连接主服务器之前睡眠的秒数）
修改完后保存退出，并重启mysql 如#service mysql restart （重启正常，表示配置没错误）
4.启动同步
进到LinuxA（Master）的mysql上：
mysql&show master status\G (查看master当前状态)
运行完以上命令显示结果如下：
File: mysql-bin.000001 （当前binlog日志文件）
Position: 98 （但前binlog日志文件位置）
Binlog_Do_DB: test （同步数据库）Binlog_Ignore_DB:
（不需同步的数据，当前为设置）-------------------------
进到LinuxB（Slave）的mysql上：
mysql&show slave status\G (查看slave同步状态)
运行完以上命令显示结果如下：
Slave_IO_State: Waiting for master to send event （slave 的io线程，获取master的binlog的日志内容，该为其目前的状态）
Master_Host: 192.168.59.123 （所需同步Master的ip地址）
Master_User: backa（同步所需的账号）
Master_Port: 3306（同步所需的mysql端口号）
Connect_Retry: 60
Master_Log_File: mysql-bin.000001 （master中的binlong的日志文件，如与master的日志文件名不同则同步失效）
Read_Master_Log_Pos: 98 （master中的binlong的日志文件的位置，即mysql-bin.000001文件中的第98位置开始同步，若与master上的位置不同则同步失效）
Relay_Log_File: localhost-relay-bin.000001
Relay_Log_Pos: 235
Relay_Master_Log_File: mysql-bin.000001
Slave_IO_Running: Yes
（Slave的io线程是否运行）
Slave_SQL_Running: Yes （slave的sql线程是否运行，需要io线程和sql线程同为yes才有效）
Replicate_Do_DB: test
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Master_Log_Pos: 98
Relay_Log_Space: 235
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: No
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Master_SSL_Key:
Seconds_Behind_Master: 0
如果Slave_IO_State：不为 Waiting for master to send event 表示未现实同步
原因可能很多先列举自己遇到：
1、 Master_Log_File: mysql-bin.000001
Read_Master_Log_Pos:98
日志文件和位置与LinuxA（Master）的当前状态不一致
解决方式：（在LinuxB的mysql操作）
mysql&(修改前先关闭slave)
mysql&change master to
&master_log_file='mysql-bin.000001'
(ps:与LinuxA中的master的日志文件名相同)
&master_log_pso=98 (ps:与LinuxA中的master的日志文件当前位置相同)
&master_user='backa'
(如果同步的账户不一致，也可在此修改)
&master_password='backa'
(如果同步的账户密码不一致，也可在此修改)
(PS:如果重新修改/f 中相关slave的配置信息，重新启动查看 slave的状态还是显示未修改的数据，应为第一次是读取my.cnf，之后就会在/var/lib/mysql/下生成一个 的文件，因此第二次就不会读取my.cnf的内容，而是读取中的内容，为此要想使重新修改的my.cnf生效的话，删除文件，重起mysql即可)
mysql&(重新启动slave)
mysql&show slave status\G (查看slave状态)
如果显示的 Slave_IO_State: Waiting for master to send event
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
祝贺成功实现单向同步即 linuxA --& linuxB 的同步；
在LinuxA的mysql上对test的 insert ， delete ，update及对表结构的修改等操作 都会同步到 LinuxB的mysql上的test数据库上
（ps：如果在master上执行如 insert into to stu (uuid(),'yushan') 则同步到 slave上 ，id不同，因为其id是用uuid生成的，所以会不一致，之后对这条数据的delete 和 update则不会实现同步）三、双向同步（LinuxA&---&LinuxB）
双向同步最好使用的mysql版本要一致，保证二进制日志binlog的格式相同；双向同步即对任何一方mysql的insert，update，delete，alter等操作都会影响到另一方mysql中的数据；由于前面已成功设置单向同步，在此基础上，把LinuxB（Slave）的配置 添加到 LinuxA(Master) 上，把LinuxA（Master）的配置添加到LinuxB（Slave）上，然后启动设置同步的binlong文件及当前位置即可,具体操作如下：
1、 LinuxA 在原有Master的基础上增加Slave （同步LinuxB 上mysql上指定的test数据库中的数据）
LinuxB 在原有Slave的基础上增加Mmaster（同步LinuxA 上mysql上指定的test数据库中的数据）；
2、在作为master（即LinuxB）的mysql上建立一个账户专门用于slave（即LinuxA）来进行数据同步
# mysql （默认用户，如设置了root密码，使用mysql -u root -p 登入mysql）
mysql&grant file on *.* to backb@'192.168.59.123' identified by 'backb'
（PS：此backb账户只能通过ip为192.168.59.123的访问）
在LinuxA上测试账户backb是否可以访问LinxuB上的mysql：
#mysql -u backb -p -h 192.168.59.124（输入密码backb，可以访问说明设置正确）
3、修改 my.cnf 文件
在LinuxA 上的/f 文件上添加Slave的配置
#server-id= 2 （mysql标示，唯一否则启动会出错误，因为原先已有标示为1，在此就可以注释掉，一个mysql只需一个标示即可）
master-host=192.168.59.124 （同步LinuxB (Master)的ip地址）
master-user=backb （同步所需的账号）
master-password=backb （同步账号的密码）
master-port=3306 （LinuxB 中mysql的访问端口）
replicate-do-db=test （所需同步的数据库名，如果是同步多个数据库，可以另起一行如 replicate-do-db=test1）
#replicate-do-table=test.stu （如果只需同步test数据库中的stu表）
#replicate-do-table=test.teacher（如果只需同步test数据库中的stu表）
master-connect-retry=60 （主服务器（Master）宕机或连接丢失的情况下，从服务器（slave）线程重新尝试连接主服务器之前睡眠的秒数）
修改完后保存退出，并重启mysql 如#service mysql restart （重启正常，表示配置没错误）
在LinxuB上的/f文件上添加Master的配置
#server-id= 1 （mysql标示,唯一否则启动会出错误，因为原先已有标示为2，在此就可以注释掉，一个mysql只需一个标示即可）
log-bin=mysql-bin （日志文件，默认存在/var/lib/mysql下日志文件以mysql-bin为开头）
#log_bin= /var/log/mysql/mysql-bin.log（也可以自己指定，在此用# 表示注释掉了）
binlog-do-db =test（需要同步的数据库名，如需同步多个数据库，可以另起行如binlog-do-db =test1 ）
修改完后保存退出，并重启mysql 如#service mysql restart （重启正常，表示配置没错误）
4.启动同步
进到LinuxB（Master）的mysql上：
mysql&show master status\G (查看master当前状态)
运行完以上命令显示结果如下：
File: mysql-bin.000003 （当前binlog日志文件）
Position: 231 （但前binlog日志文件位置）
Binlog_Do_DB: test （同步数据库）Binlog_Ignore_DB:
（不需同步的数据，当前为设置） -------------------------
进到LinuxA（Slave）的mysql上：
mysql&show slave status\G (查看slave同步状态)
运行完以上命令显示结果如下：
Slave_IO_State: Waiting for master to send event （slave 的io线程，获取master的binlog的日志内容，该为其目前的状态）
Master_Host: 192.168.59.124 （所需同步Master的ip地址）
Master_User: backb（同步所需的账号）
Master_Port: 3306（同步所需的mysql端口号）
Connect_Retry: 60
Master_Log_File: mysql-bin.000003 （master中的binlong的日志文件，如与master的日志文件名不同则同步失效）
Read_Master_Log_Pos: 98 （master中的binlong的日志文件的位置，即mysql-bin.000001文件中的第98位置开始同步，若与master上的位置不同则同步失效）
Relay_Log_File: localhost-relay-bin.000001
Relay_Log_Pos: 231
Relay_Master_Log_File: mysql-bin.000001
Slave_IO_Running: Yes
（Slave的io线程是否运行）
Slave_SQL_Running: Yes （slave的sql线程是否运行，需要io线程和sql线程同为yes才有效）
Replicate_Do_DB: test
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Master_Log_Pos: 98
Relay_Log_Space: 235
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: No
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Master_SSL_Key:
Seconds_Behind_Master: 0
以上显示为正确同步 如果显示的一下数据不是
Slave_IO_State: Waiting for master to send event
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
若与以上的三个状态表示不同，则未实现同步；可以采用以上单向同步中的 change master 进行重新设置（ps：防火墙需关闭）
以上都能正确配置完且显示的状态一致，那么祝贺您成功实现双向同步即 linuxA &--& linuxB 的同步；
四、 mysql 数据同步相关说明（转载于网络，google一下很多） 1. 同步机制实现概述 MySQL同步机制基于master把所有对数据库的更新操作(更新、删除 等)都记录在二进制日志里。因此，想要启用同步机制，在master就必须启用二进制日志。 每个slave接受来自master上在二进制日志中记录的更新操作，因此在slave上执行了这个操作的一个拷贝。应该非常重要地意识到，二进制日志只是从启用二进制日志开始的时刻才记录更新操作的。所有的slave必须在启用二进制日志时把master上已经存在的数据拷贝过来。如果运行同步时slave上的数据和master上启用二进制日志时的数据不一致的话，那么slave同步就会失败。 2. 同步实现细节 MySQL同步功能由3个线程(master上1个，slave上2个)来实现。执行 START SLAVE 语句后，slave就创建一个I/O线程。I/O线程连接到master上，并请求master发送二进制日志中的语句。master创建一个线程来把日志的内容发送到slave上。这个线程在master上执行 SHOW PROCESSLIST 语句后的结果中的 Binlog Dump 线程便是。slave上的I/O线程读取master的 Binlog Dump 线程发送的语句，并且把它们拷贝到其数据目录下的中继日志(relay logs)中。第三个是SQL线程，salve用它来读取中继日志，然后执行它们来更新数据。 如上所述，每个mster/slave上都有3个线程。每个master上有多个线程，它为每个slave连接都创建一个线程，每个slave只有I/O和SQL线程。 在MySQL 4.0.2以前，同步只需2个线程(master和slave各一个)。slave上的I/O和SQL线程合并成一个了，它不使用中继日志。 slave上使用2个线程的优点是，把读日志和执行分开成2个独立的任务。执行任务如果慢的话，读日志任务不会跟着慢下来。例如，如果 slave停止了一段时间，那么I/O线程可以在slave启动后很快地从master上读取全部日志，尽管SQL线程可能落后I/O线程好几的小时。如果slave在SQL线程没全部执行完就停止了，不过I/O线程却已经把所有的更新日志都读取并且保存在本地的中继日志中了，因此在slave再次启动后就会继续执行它们了。这就允许在master上清除二进制日志，因为slave已经无需去master读取更新日志了。 在mysql中执行 SHOW PROCESSLIST 语句就会告诉我们所关心的master和slave上发生的情况 在master上，SHOW PROCESSLIST 的结果如下： mysql& SHOW PROCESSLIST\G *************************** 1. row *************************** Id: 21 User: root Host: localhost db: mysql Command: Query Time: 0 State: NULL Info: SHOW PROCESSLIST *************************** 2. row (MASTER线程)*************************** Id: 25 User: back Host: 192.168.1.125:34085 db: NULL Command: Binlog Dump Time: 746 State: Has sent waiting for binlog to be updated Info: NULL 2 rows in set (0.01 sec) 在这里，线程2是为一个slave连接创建的。结果表明所有未完成的更新日志已经都发送到slave了，master正等待新的更新日志发生。 在slave上，SHOW PROCESSLIST 的结果如下： mysql& SHOW PROCESSLIST\G *************************** 1. row *************************** Id: 2 User: system user Host: db: NULL Command: Connect Time: 70479 State: Waiting for master to send event Info: NULL *************************** 2. row (I/O线程) *************************** Id: 3 User: system user Host: db: NULL Command: Connect Time: 16971 State: Ha waiting for the slave I/O thread to update it Info: NULL *************************** 3. row (SQL线程)*************************** Id: 8 User: root Host: localhost db: NULL Command: Query Time: 0 State: NULL Info: SHOW PROCESSLIST 3 rows in set (0.00 sec) 这表明线程2是I/O线程，它正连接到master上；线程3是SQL线程，它执行中继日志中的更新操作。现在，这2个线程都处于空闲状态，正等待新的更新日志。 注意，Time 字段的值告诉我们slave上的日志比master晚了多久。 3. Master 同步线程状态 以下列出了master的 Binlog Dump 线程 State 字段中最常见的几种状态。如果在master上没有 Binlog Dump 线程，那么同步就没有在运行。也就是说，没有slave连接上来。 Sending binlog event to slave 事件是由二进制日志构成，一个事件通常由更新语句加上其他信息。线程读取到一个事件并正发送到slave上。 Finishe switching to next binlog 读取完了一个二进制日志，正切换到下一个。 Has sent waiting for binlog to be updated 已经读取完全部未完成更新日志，并且全部都发送到slave了。它处于空闲状态，正等待在master上执行新的更新操作以在二进制日志中产生新的事件，然后读取它们。 Waiting to finalize termination 当前线程停止了，这个时间很短 4. Slave的I/O线程状态 以下列出了slave的I/O线程 State 字段中最常见的几种状态。从MySQL 4.1.1开始，这个状态在执行 SHOW SLAVE STATUS 语句结果的 Slave_IO_State 字段也会出现。这意味着可以只执行 SHOW SLAVE STATUS 语句就能了解到更多的信息。 Connecting to master 该线程证尝试连接到master上。 Checking master version 确定连接到master后出现的一个短暂的状态。 Registering slave on master 确定连接到master后出现的一个短暂的状态。 Requesting binlog dump 确定连接到master后出现的一个短暂的状态。该线程向master发送一个请求，告诉它要请求的二进制文件以及开始位置。 Waiting to reconnect after a failed binlog dump request 如果二进制日志转储(binary log dump)请求失败了(由于连接断开)，该线程在休眠时进入这个状态，并定期重连。重连的时间间隔由 --master-connect-retry 选项来指定。 Reconnecting after a failed binlog dump request 该线程正尝试重连到master。 Waiting for master to send event 已经连接到master，正等待它发送二进制日志。如果master闲置时，这个状态可能会持续较长时间，如果它等待超过 slave_read_timeout 秒，就会发生超时。这时，它就会考虑断开连接，然后尝试重连。 Queueing master event to the relay log 已经读取到一个事件，正把它拷贝到中继日志中以备SQL线程处理。 Waiting to reconnect after a failed master event read 读日志时发生错误(由于连接断开)。该线程在重连之前休眠 master-connect-retry 秒。 Reconnecting after a failed master event read 正尝试重连到master。当连接确定后，状态就变成 Waiting for master to send event。 Waiting for the slave SQL thread to free enough relay log space relay_log_space_limit 的值非零，中继日志的大小总和超过这个值了。I/O线程等待SQL线程先处理中继日志然后删除它们以释放足够的空间。 Waiting for slave mutex on exit 当前线程停止了，这个时间很短。 5. Slave的SQL线程状态 以下列出了slave的SQL线程 State 字段中最常见的几种状态： Reading event from the relay log 从中继日志里读到一个事件以备执行。 Ha waiting for the slave I/O thread to update it 已经处理完中继日志中的全部事件了，正等待I/O线程写入更新的日志。 Waiting for slave mutex on exit 当前线程停止了，这个时间很短。 SQL线程的 State 字段有时候也可能是一个SQL语句。这意味着它从中继日志中读取到一个事件了，从中提取出SQL语句，并执行它。
（自己画的mysql同步原理图）
相关mysql数据同步资料的连接：
http://deidara./039
/tech/database//65.html
scn.org/htm_data/288/.html
http://www.koven.org/archives/203.html
/harryguo/archive//1099223.html
http://www.blogjava.net/lzj520/archive//182485.html
spring经典注脚实例二 10分钟弄懂
spring经典注解实例二 10分钟弄懂
昨天对Spring注解有了一个整体认识，至少完成了一个简单的web应用搭建。当然，还不完善，这仅仅只是个开始！ 今天看了Spring 3.0的注解，我感觉自己被颠覆了。多年前，为了减少代码依赖我们用配置文件进行模块间耦合，降低模块之间的黏度。现如今，所有可配置的内容都塞进了代码中，我只能说：这多少有点顾此失彼，有点倒退的意思！使用注解的好处是：代码通读性增强。这既是优势也是劣势！如果我要改一段配置，就要打开代码逐行扫描；如果恰巧这是别人封装的jar包，那我只好反编译；如果碰巧遇上这个jar包经过了混淆，那我只好求助于AOP了。 为了这么一个配置，我的代码观几乎将要被颠覆！言归正传，研究一下注解下的控制层。 我习惯于使用JSTL展示页面，因此需要在原lib基础上增加jstl.jar和standard.jar，详细lib依赖如下：引用aopalliance-1.0.jar commons-logging-1.1.1.jar log4j-1.2.15.jar spring-beans-2.5.6.jar spring-context-2.5.6.jar spring-context-support-2.5.6.jar spring-core-2.5.6.jar spring-tx-2.5.6.jar spring-web-2.5.6.jar spring-webmvc-2.5.6.jar standard.jar jstl.jar 上一篇文中，我们定义了控制器AccountController： AccountController.javaJava代码
4.package org.zlex.spring.
6.import javax.servlet.http.HttpServletR
7.import javax.servlet.http.HttpServletR
9.import org.springframework.beans.factory.annotation.A
10.import org.springframework.stereotype.C
11.import org.springframework.web.bind.ServletRequestU
12.import org.springframework.web.bind.annotation.RequestM
13.import org.springframework.web.bind.annotation.RequestM
14.import org.zlex.spring.service.AccountS
18. * @author &a href="mailto:zlex."&梁栋&/a&
19. * @version 1.0
20. * @since 1.0
22.@Controller
23.@RequestMapping("/account.do")
24.public class AccountController {
@Autowired
private AccountService accountS
@RequestMapping(method = RequestMethod.GET)
public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password));
Java代码 1./**
4.package org.zlex.spring.
6.import javax.servlet.http.HttpServletR
7.import javax.servlet.http.HttpServletR
9.import org.springframework.beans.factory.annotation.A
10.import org.springframework.stereotype.C
11.import org.springframework.web.bind.ServletRequestU
12.import org.springframework.web.bind.annotation.RequestM
13.import org.springframework.web.bind.annotation.RequestM
14.import org.zlex.spring.service.AccountS
18. * @author &a href="mailto:zlex."&梁栋&/a&
19. * @version 1.0
20. * @since 1.0
22.@Controller
23.@RequestMapping("/account.do")
24.public class AccountController {
@Autowired
private AccountService accountS
@RequestMapping(method = RequestMethod.GET)
public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password));
*/package org.zlex.spring.import javax.servlet.http.HttpServletRimport javax.servlet.http.HttpServletRimport org.springframework.beans.factory.annotation.Aimport org.springframework.stereotype.Cimport org.springframework.web.bind.ServletRequestUimport org.springframework.web.bind.annotation.RequestMimport org.springframework.web.bind.annotation.RequestMimport org.zlex.spring.service.AccountS/** *
* @author &a href="mailto:zlex."&梁栋&/a& * @version 1.0 * @since 1.0 */@Controller@RequestMapping("/account.do")public class AccountController { @Autowired private AccountService accountS @RequestMapping(method = RequestMethod.GET) public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password)); }}先说注解@RequestMapping 这里使用注解@RequestMapping(method = RequestMethod.GET)指定这个方法为get请求时调用。同样，我们可以使用注解@RequestMapping(method = RequestMethod.POST)指定该方法接受post请求。Java代码
1.@Controller
2.@RequestMapping("/account.do")
3.public class AccountController {
@RequestMapping(method = RequestMethod.GET)
public void get() {
@RequestMapping(method = RequestMethod.POST)
public void post() {
Java代码 1.@Controller
2.@RequestMapping("/account.do")
3.public class AccountController {
@RequestMapping(method = RequestMethod.GET)
public void get() {
@RequestMapping(method = RequestMethod.POST)
public void post() {
@Controller@RequestMapping("/account.do")public class AccountController { @RequestMapping(method = RequestMethod.GET) public void get() { } @RequestMapping(method = RequestMethod.POST) public void post() { }}这与我们久别的Servlet很相像，类似于doGet()和doPost()方法！ 我们也可以将其改造为多动作控制器，如下代码所示：Java代码
1.@Controller
2.@RequestMapping("/account.do")
3.public class AccountController {
@RequestMapping(params = "method=login")
public void login() {
@RequestMapping(params = "method=logout")
public void logout() {
Java代码 1.@Controller
2.@RequestMapping("/account.do")
3.public class AccountController {
@RequestMapping(params = "method=login")
public void login() {
@RequestMapping(params = "method=logout")
public void logout() {
@Controller@RequestMapping("/account.do")public class AccountController { @RequestMapping(params = "method=login")
public void login() { } @RequestMapping(params = "method=logout")
public void logout() { }这样，我们可以通过参数“method”指定不同的参数值从而通过请求（"/account.do?method=login"和"/account.do?method=logout"）调用不同的方法！注意：使用多动作控制器必须在配置文件中加入注解支持！Xml代码
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&
Xml代码 1.&bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&当然，我们也可以将注解@RequestMapping指定到某一个方法上，如：Java代码
1.@Controller
2.public class AccountController {
@RequestMapping("/a.do")
public void a() {}
@RequestMapping("/b.do")
public void b() {}
Java代码 1.@Controller
2.public class AccountController {
@RequestMapping("/a.do")
public void a() {}
@RequestMapping("/b.do")
public void b() {}
@Controllerpublic class AccountController { @RequestMapping("/a.do") public void a() {} @RequestMapping("/b.do") public void b() {}}这样，请求“a.do”和“b.do”将对应不同的方法a() 和b()。这使得一个控制器可以同时承载多个请求！ @RequestMapping("/account.do")是@RequestMapping(value="/account.do")的简写！ 再说输入参数！ 这里的方法名可以随意定义，但是参数和返回值却又要求！ 为什么？直接看源代码，我们就能找到答案！AnnotationMethodHandlerAdapter.java部分源代码——有关参数部分：Java代码
1.@Override
2.protected Object resolveStandardArgument(Class parameterType, NativeWebRequest webRequest)
throws Exception {
HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
HttpServletResponse response = (HttpServletResponse) webRequest.getNativeResponse();
if (ServletRequest.class.isAssignableFrom(parameterType)) {
else if (ServletResponse.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
else if (HttpSession.class.isAssignableFrom(parameterType)) {
return request.getSession();
else if (Principal.class.isAssignableFrom(parameterType)) {
return request.getUserPrincipal();
else if (Locale.class.equals(parameterType)) {
return RequestContextUtils.getLocale(request);
else if (InputStream.class.isAssignableFrom(parameterType)) {
return request.getInputStream();
else if (Reader.class.isAssignableFrom(parameterType)) {
return request.getReader();
else if (OutputStream.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getOutputStream();
else if (Writer.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getWriter();
return super.resolveStandardArgument(parameterType, webRequest);
Java代码 1.@Override
2.protected Object resolveStandardArgument(Class parameterType, NativeWebRequest webRequest)
throws Exception {
HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
HttpServletResponse response = (HttpServletResponse) webRequest.getNativeResponse();
if (ServletRequest.class.isAssignableFrom(parameterType)) {
else if (ServletResponse.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
else if (HttpSession.class.isAssignableFrom(parameterType)) {
return request.getSession();
else if (Principal.class.isAssignableFrom(parameterType)) {
return request.getUserPrincipal();
else if (Locale.class.equals(parameterType)) {
return RequestContextUtils.getLocale(request);
else if (InputStream.class.isAssignableFrom(parameterType)) {
return request.getInputStream();
else if (Reader.class.isAssignableFrom(parameterType)) {
return request.getReader();
else if (OutputStream.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getOutputStream();
else if (Writer.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getWriter();
return super.resolveStandardArgument(parameterType, webRequest);
protected Object resolveStandardArgument(Class parameterType, NativeWebRequest webRequest)
throws Exception {
HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
HttpServletResponse response = (HttpServletResponse) webRequest.getNativeResponse();
if (ServletRequest.class.isAssignableFrom(parameterType)) {
else if (ServletResponse.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
else if (HttpSession.class.isAssignableFrom(parameterType)) {
return request.getSession();
else if (Principal.class.isAssignableFrom(parameterType)) {
return request.getUserPrincipal();
else if (Locale.class.equals(parameterType)) {
return RequestContextUtils.getLocale(request);
else if (InputStream.class.isAssignableFrom(parameterType)) {
return request.getInputStream();
else if (Reader.class.isAssignableFrom(parameterType)) {
return request.getReader();
else if (OutputStream.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getOutputStream();
else if (Writer.class.isAssignableFrom(parameterType)) {
this.responseArgumentUsed =
return response.getWriter();
return super.resolveStandardArgument(parameterType, webRequest);
}也就是说，如果我们想要在自定义的方法中获得一些个“标准”输入参数，参数类型必须包含在以下类型中：引用ServletRequest ServletResponse HttpSession Principal Locale InputStream OutputStream Reader Writer 当然，上述接口其实都是对于HttpServletRequest和HttpServletResponse的扩展。 此外，我们还可以定义自己的参数。 注意：自定义参数必须是实现类，绝非接口！Spring容器将帮你完成对象初始化工作！ 比如说上文中，我们需要参数username和password。我们可以这么写：Java代码
1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(String username,String password) {
System.out.println(accountService.verify(username, password));
Java代码 1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(String username,String password) {
System.out.println(accountService.verify(username, password));
@RequestMapping(method = RequestMethod.GET) public void hello(String username,String password) {
System.out.println(accountService.verify(username, password)); }如果参数名不能与这里的变量名保持一致，那么我们可以使用注解@RequestParam进行强制绑定，代码如下所示：Java代码
1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(@RequestParam("username") String u,
@RequestParam("password") String p) {
System.out.println(accountService.verify(u, p));
Java代码 1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(@RequestParam("username") String u,
@RequestParam("password") String p) {
System.out.println(accountService.verify(u, p));
@RequestMapping(method = RequestMethod.GET) public void hello(@RequestParam("username") String u,
@RequestParam("password") String p) {
System.out.println(accountService.verify(u, p)); }这比起我们之前写的代码有所简洁：Java代码
1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password));
Java代码 1.@RequestMapping(method = RequestMethod.GET)
2.public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password));
@RequestMapping(method = RequestMethod.GET) public void hello(HttpServletRequest request, HttpServletResponse response)
throws Exception {
String username = ServletRequestUtils.getRequiredStringParameter(
request, "username");
String password = ServletRequestUtils.getRequiredStringParameter(
request, "password");
System.out.println(accountService.verify(username, password)); }ServletRequestUtils类的工作已经由Spring底层实现了，我们只需要把参数名定义一致即可，其内部取参无需关心！除了传入参数，我们还可以定义即将传出的参数，如加入ModelMap参数：Java代码
1.@SuppressWarnings("unchecked")
2.@RequestMapping(method = RequestMethod.GET)
3.public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
Java代码 1.@SuppressWarnings("unchecked")
2.@RequestMapping(method = RequestMethod.GET)
3.public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
@SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
}这时，我们没有定义页面名称，Spring容器将根据请求名指定同名view，即如果是jap页面，则account.do-&account.jsp！ 不得不承认，这样写起来的确减少了代码量！接着说输出参数！ 通过ModelMap，我们可以绑定输出到的页面的参数，但最终我们将要返回到何种页面呢？再次查看AnnotationMethodHandlerAdapter源代码！ AnnotationMethodHandlerAdapter.java部分源代码——有关返回值部分：Java代码
1.@SuppressWarnings("unchecked")
2.public ModelAndView getModelAndView(Method handlerMethod, Class handlerType, Object returnValue,
ExtendedModelMap implicitModel, ServletWebRequest webRequest) {
if (returnValue instanceof ModelAndView) {
ModelAndView mav = (ModelAndView) returnV
mav.getModelMap().mergeAttributes(implicitModel);
else if (returnValue instanceof Model) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects(((Model) returnValue).asMap());
else if (returnValue instanceof Map) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects((Map) returnValue);
else if (returnValue instanceof View) {
return new ModelAndView((View) returnValue).addAllObjects(implicitModel);
else if (returnValue instanceof String) {
return new ModelAndView((String) returnValue).addAllObjects(implicitModel);
else if (returnValue == null) {
// Either returned null or was 'void' return.
if (this.responseArgumentUsed || webRequest.isNotModified()) {
// Assuming view name translation...
return new ModelAndView().addAllObjects(implicitModel);
else if (!BeanUtils.isSimpleProperty(returnValue.getClass())) {
// Assume a single model attribute...
ModelAttribute attr = AnnotationUtils.findAnnotation(handlerMethod, ModelAttribute.class);
String attrName = (attr != null ? attr.value() : "");
ModelAndView mav = new ModelAndView().addAllObjects(implicitModel);
if ("".equals(attrName)) {
Class resolvedType = GenericTypeResolver.resolveReturnType(handlerMethod, handlerType);
attrName = Conventions.getVariableNameForReturnType(handlerMethod, resolvedType, returnValue);
return mav.addObject(attrName, returnValue);
throw new IllegalArgumentException("Invalid handler method return value: " + returnValue);
Java代码 1.@SuppressWarnings("unchecked")
2.public ModelAndView getModelAndView(Method handlerMethod, Class handlerType, Object returnValue,
ExtendedModelMap implicitModel, ServletWebRequest webRequest) {
if (returnValue instanceof ModelAndView) {
ModelAndView mav = (ModelAndView) returnV
mav.getModelMap().mergeAttributes(implicitModel);
else if (returnValue instanceof Model) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects(((Model) returnValue).asMap());
else if (returnValue instanceof Map) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects((Map) returnValue);
else if (returnValue instanceof View) {
return new ModelAndView((View) returnValue).addAllObjects(implicitModel);
else if (returnValue instanceof String) {
return new ModelAndView((String) returnValue).addAllObjects(implicitModel);
else if (returnValue == null) {
// Either returned null or was 'void' return.
if (this.responseArgumentUsed || webRequest.isNotModified()) {
// Assuming view name translation...
return new ModelAndView().addAllObjects(implicitModel);
else if (!BeanUtils.isSimpleProperty(returnValue.getClass())) {
// Assume a single model attribute...
ModelAttribute attr = AnnotationUtils.findAnnotation(handlerMethod, ModelAttribute.class);
String attrName = (attr != null ? attr.value() : "");
ModelAndView mav = new ModelAndView().addAllObjects(implicitModel);
if ("".equals(attrName)) {
Class resolvedType = GenericTypeResolver.resolveReturnType(handlerMethod, handlerType);
attrName = Conventions.getVariableNameForReturnType(handlerMethod, resolvedType, returnValue);
return mav.addObject(attrName, returnValue);
throw new IllegalArgumentException("Invalid handler method return value: " + returnValue);
@SuppressWarnings("unchecked")
public ModelAndView getModelAndView(Method handlerMethod, Class handlerType, Object returnValue,
ExtendedModelMap implicitModel, ServletWebRequest webRequest) {
if (returnValue instanceof ModelAndView) {
ModelAndView mav = (ModelAndView) returnV
mav.getModelMap().mergeAttributes(implicitModel);
else if (returnValue instanceof Model) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects(((Model) returnValue).asMap());
else if (returnValue instanceof Map) {
return new ModelAndView().addAllObjects(implicitModel).addAllObjects((Map) returnValue);
else if (returnValue instanceof View) {
return new ModelAndView((View) returnValue).addAllObjects(implicitModel);
else if (returnValue instanceof String) {
return new ModelAndView((String) returnValue).addAllObjects(implicitModel);
else if (returnValue == null) {
// Either returned null or was 'void' return.
if (this.responseArgumentUsed || webRequest.isNotModified()) {
// Assuming view name translation...
return new ModelAndView().addAllObjects(implicitModel);
else if (!BeanUtils.isSimpleProperty(returnValue.getClass())) {
// Assume a single model attribute...
ModelAttribute attr = AnnotationUtils.findAnnotation(handlerMethod, ModelAttribute.class);
String attrName = (attr != null ? attr.value() : "");
ModelAndView mav = new ModelAndView().addAllObjects(implicitModel);
if ("".equals(attrName)) {
Class resolvedType = GenericTypeResolver.resolveReturnType(handlerMethod, handlerType);
attrName = Conventions.getVariableNameForReturnType(handlerMethod, resolvedType, returnValue);
return mav.addObject(attrName, returnValue);
throw new IllegalArgumentException("Invalid handler method return value: " + returnValue);
} }返回值的定义十分庞大，或者说可怕的if-else多少有点让我觉得厌恶！我们可以定义以下类型的返回值：引用ModelAndView Model View Map String null ModelAndView、Model和View都是Spring之前版本所特有的元素，Map对应于传入参数ModelMap，String定义页面名称，null即对应void类型方法！ 最常用的实现方式如下：Java代码
1.@SuppressWarnings("unchecked")
2.@RequestMapping(method = RequestMethod.GET)
3.public String hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
return "account";
Java代码 1.@SuppressWarnings("unchecked")
2.@RequestMapping(method = RequestMethod.GET)
3.public String hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
return "account";
@SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) public String hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
return "account"; }当然，对于我来说在返回值中写入这么一个字符串多少有点不能接受，于是我还是乐于使用输入参数ModelMap+输出参数Map的方式。 给出一个完整的AccountController实现： AccountController.javaJava代码
4.package org.zlex.spring.
6.import java.util.M
8.import org.springframework.beans.factory.annotation.A
9.import org.springframework.stereotype.C
10.import org.springframework.ui.ModelM
11.import org.springframework.web.bind.annotation.RequestM
12.import org.springframework.web.bind.annotation.RequestM
13.import org.zlex.spring.service.AccountS
17. * @author &a href="mailto:zlex."&梁栋&/a&
18. * @version 1.0
19. * @since 1.0
21.@Controller
22.@RequestMapping("/account.do")
23.public class AccountController {
@Autowired
private AccountService accountS
@SuppressWarnings("unchecked")
@RequestMapping(method = RequestMethod.GET)
public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
Java代码 1./**
4.package org.zlex.spring.
6.import java.util.M
8.import org.springframework.beans.factory.annotation.A
9.import org.springframework.stereotype.C
10.import org.springframework.ui.ModelM
11.import org.springframework.web.bind.annotation.RequestM
12.import org.springframework.web.bind.annotation.RequestM
13.import org.zlex.spring.service.AccountS
17. * @author &a href="mailto:zlex."&梁栋&/a&
18. * @version 1.0
19. * @since 1.0
21.@Controller
22.@RequestMapping("/account.do")
23.public class AccountController {
@Autowired
private AccountService accountS
@SuppressWarnings("unchecked")
@RequestMapping(method = RequestMethod.GET)
public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
*/package org.zlex.spring.import java.util.Mimport org.springframework.beans.factory.annotation.Aimport org.springframework.stereotype.Cimport org.springframework.ui.ModelMimport org.springframework.web.bind.annotation.RequestMimport org.springframework.web.bind.annotation.RequestMimport org.zlex.spring.service.AccountS/** *
* @author &a href="mailto:zlex."&梁栋&/a& * @version 1.0 * @since 1.0 */@Controller@RequestMapping("/account.do")public class AccountController { @Autowired private AccountService accountS @SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
}}最后说注解@Session 如果想将某个ModelMap中的参数指定到Session中，可以使用@Session注解，将其绑定为Session熟悉，代码如下所示：Java代码
1.@Controller
2.@RequestMapping("/account.do")
3.@SessionAttributes("msg")
4.public class AccountController {
@Autowired
private AccountService accountS
@SuppressWarnings("unchecked")
@RequestMapping(method = RequestMethod.GET)
public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
Java代码 1.@Controller
2.@RequestMapping("/account.do")
3.@SessionAttributes("msg")
4.public class AccountController {
@Autowired
private AccountService accountS
@SuppressWarnings("unchecked")
@RequestMapping(method = RequestMethod.GET)
public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
@Controller@RequestMapping("/account.do")@SessionAttributes("msg")public class AccountController { @Autowired private AccountService accountS @SuppressWarnings("unchecked") @RequestMapping(method = RequestMethod.GET) public Map hello(String username, String password, ModelMap model) {
System.out.println(accountService.verify(username, password));
model.put("msg", username);
}}当然，我们还需要配置一下对应的视图解析器，给出完整配置： servelt.xmlXml代码
1.&?xml version="1.0" encoding="UTF-8"?&
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
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"&
&context:component-scan
base-package="org.zlex.spring.controller" /&
id="urlMapping"
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /&
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&
id="jstlViewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:viewClass="org.springframework.web.servlet.view.JstlView"
p:prefix="/WEB-INF/page/"
p:suffix=".jsp" /&
22.&/beans&
Xml代码 1.&?xml version="1.0" encoding="UTF-8"?&
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
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"&
&context:component-scan
base-package="org.zlex.spring.controller" /&
id="urlMapping"
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /&
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /&
id="jstlViewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:viewClass="org.springframework.web.servlet.view.JstlView"
p:prefix="/WEB-INF/page/"
p:suffix=".jsp" /&
22.&/beans&
&?xml version="1.0" encoding="UTF-8"?&&beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 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"& &context:component-scan
base-package="org.zlex.spring.controller" /& &bean
id="urlMapping"
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /& &bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" /& &bean
id="jstlViewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:viewClass="org.springframework.web.servlet.view.JstlView"
p:prefix="/WEB-INF/page/"
p:suffix=".jsp" /&&/beans&这里使用了JstlView作为视图解析器。同时，指定前缀路径为"/WEB-INF/page/"，后缀路径为".jsp"。也就是说，Spring容器将会在这个路径中寻找匹配的jsp文件！ 注意加入xmlns:p="http://www.springframework.org/schema/p"命名空间！ 再给出页面内容： taglib.jspJsp代码
1.&%@ taglib prefix="c" uri="/jsp/jstl/core"%&
2.&%@ taglib prefix="fmt" uri="/jsp/jstl/fmt"%&
3.&%@ taglib prefix="sql" uri="/jsp/jstl/sql"%&
4.&%@ taglib prefix="x" uri="/jsp/jstl/xml"%&
5.&%@ taglib prefix="fn" uri="/jsp/jstl/functions"%&
6.&%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%&
7.&%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%&
Jsp代码 1.&%@ taglib prefix="c" uri="/jsp/jstl/core"%&
2.&%@ taglib prefix="fmt" uri="/jsp/jstl/fmt"%&
3.&%@ taglib prefix="sql" uri="/jsp/jstl/sql"%&
4.&%@ taglib prefix="x" uri="/jsp/jstl/xml"%&
5.&%@ taglib prefix="fn" uri="/jsp/jstl/functions"%&
6.&%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%&
7.&%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%&
&%@ taglib prefix="c" uri="/jsp/jstl/core"%&&%@ taglib prefix="fmt" uri="/jsp/jstl/fmt"%&&%@ taglib prefix="sql" uri="/jsp/jstl/sql"%&&%@ taglib prefix="x" uri="/jsp/jstl/xml"%&&%@ taglib prefix="fn" uri="/jsp/jstl/functions"%&&%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%&&%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%&account.japJsp代码
1.&%@ page language="java" contentType="text/ charset=UTF-8"
pageEncoding="UTF-8"%&
3.&%@ include file="/WEB-INF/page/taglib.jsp"%&
4.&!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"&
7.&meta http-equiv="Content-Type" content="text/ charset=UTF-8"&
8.&title&Account&/title&
11.&c:out value="${msg}"&&/c:out&
12.&/body&
13.&/html&
Jsp代码 1.&%@ page language="java" contentType="text/ charset=UTF-8"
pageEncoding="UTF-8"%&
3.&%@ include file="/WEB-INF/page/taglib.jsp"%&
4.&!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"&
7.&meta http-equiv="Content-Type" content="text/ charset=UTF-8"&
8.&title&Account&/title&
11.&c:out value="${msg}"&&/c:out&
12.&/body&
13.&/html&
&%@ page language="java" contentType="text/ charset=UTF-8" pageEncoding="UTF-8"%&&%@ include file="/WEB-INF/page/taglib.jsp"%&&!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"&&html&&head&&meta http-equiv="Content-Type" content="text/ charset=UTF-8"&&title&Account&/title&&/head&&body&&c:out value="${msg}"&&/c:out&&/body&&/html&目录结构如图所示： 启动应用，最后将得到一个带有内容的页面，如图： 代码见附件！
如果您想提高自己的技术水平，欢迎加入本站官方1号QQ群：&&，&&2号QQ群：，在群里结识技术精英和交流技术^_^
本站联系邮箱：}
我要回帖
更多关于 xampp zend 的文章
更多推荐
- ·如何辨认李宁飞电跑鞋图片3真假呢？
- ·如何将Mflacmp3格式转换器成MP3？
- ·macbookair官网 Air转换器在哪儿买？
- ·求一部比较老的吸血鬼电影，吸血鬼最后在墓室里被杀，画面最后是一个尸体挂在铁栏上燃烧
- ·问一下这两个八字判断结婚时间怎么样正婚什么时候？
- ·求小学数学<三角形的内角和内角和>教学设计
- ·新视野大学英语语1作业，求高手完成，万分感谢~~字数限制，下面继续~~
- ·哪里的陈列设计师培训最专业？最哪里能学到黑客技术真正的本领？
- ·草酸在辽中县政府哪有卖的？
- ·德中国有哪些知名大学的工科大学？
- ·高中大学物理简谐运动（简谐）
- ·章鱼和章鱼跟乌贼的区别别?????
- ·拜求土木工程施工技术的施工步骤，越细越好，如：基础需要哪些步骤等
- ·莱阳数控中级技工证考试在哪报名
- ·驱动程序下载时有一个测绘控制点点下载,这个测绘控制点点是什么
- ·土木工程研究生专业群是多少啊
- ·考《电焊工高级技师证怎么考》需要具备哪些条件?
- ·CZO-150直交流接触器接线图上电后不动作。
- ·最新【成仁高清影视首页】在线地址成仁高清影视首页快速进入
- ·xampp zend设置密码问题
- ·难以解释的世界怪异现象象
- ·请问在华夏名网域名注册域名安全不？
- ·清华同方iphone大小写切换换显示
- ·已知m二叉树后序遍历和前序遍历，求有多少种树，高手指点下
- ·怎样制作钟闹灯亮了小制作
- ·给 我 一 个
- ·在家里用本上网网速和电脑都没有问题 但是一到晚上网速就慢学校 连上网以后 上网网页老是不动 鼠标点图标也点不开
- ·电脑启动出现ifying dmi pool data硬盘word启动失败败
- ·手机丢了怎么找回来买回来插上卡不反应
- ·求一个Java MVC的图片上传功能代码例子，类似人人网如何上传视频上传图片的。要能在Myeclipse 上跑得代码。高分求！
- ·打印机能效标识被移动存储介质标识安全管理系统屏蔽了怎么办?
- ·单片机延时程序按1显示1,在按1和2显示21程序?
- ·3dmax打包视屏教程（全）打包下载
- ·帮忙辨别一下希捷保修期移动硬盘的真伪和保修期，P/N:9CA154-784，S/N:9QMCONB5。烦请告知查询结果。
- ·求CAD完整cad教程下载
