Java消息中间件入门笔记 - ActiveMQ篇
入门
消息中间件带来的好处：
1）解耦：系统解耦
2）异步：异步执行
3）横向扩展
4）安全可靠
5）顺序保证栗子：
通过服务调用让其它系统感知事件发生
系统之间高耦合
程序执行效率低
通过消息中间件解耦服务调用
1.Linux安装消息中间件ActiveMQ
1.下载安装包
wget http://120.221.32.78:6510/mirrors.shu.edu.cn/apache//activemq/5.15.3/apache-activemq-5.15.3-bin.tar.gz
解压
tar -zxvf apache-activemq-5.15.3-bin.tar.gz
2.启动与关闭
进入到bin目录，使用命令./activemq start启动服务
使用命令ps -ef |grep activemq查看进程是否存在
使用命令./activemq stop关闭服务3.安装验证
访问地址：http://Linux主机IP:8161/
默认用户：admin
默认密码：admin4.Maven依赖
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-all</artifactId>
<version>5.15.3</version>
</dependency>2.队列模式的消息演示
队列模式：
1）客户端包括生产者和消费者
2）队列中的消息只能被一个消费者消费
3）消费者可以随时消费
1.编写AppProducer类
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
/**
* App 生产者-队列模式
* @author
*
*/
public class AppProducer {
/** 指定ActiveMQ服务的地址 */
private static final String URL = "tcp://127.0.0.1:61616";
/** 指定队列的名称 */
private static final String QUEUE_NAME = "queue-test";
public static void main(String[] args) throws JMSException {
// 1.创建ConnectionFactory
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(URL);
// 2.创建Connection
Connection connection = connectionFactory.createConnection();
// 3.启动连接
connection.start();
// 4.创建会话（第一个参数：是否在事务中处理）
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 5. 创建一个目标
Destination destination = session.createQueue(QUEUE_NAME);
// 6.创建一个生产者
MessageProducer producer = session.createProducer(destination);
for (int i = 0; i < 100; i++) {
// 7.创建消息
TextMessage textMessage = session.createTextMessage("test" + i);
// 8.发布消息
producer.send(textMessage);
System.out.println("消息发送：" + textMessage.getText());
}
// 9.关闭连接
connection.close();
}
}2.编写AppConsumer类
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
/**
* App 消费者-队列模式
* @author
*
*/
public class AppConsumer {
/** 指定ActiveMQ服务的地址 */
private static final String URL = "tcp://127.0.0.1:61616";
/** 指定队列的名称 */
private static final String QUEUE_NAME = "queue-test";
public static void main(String[] args) throws JMSException {
// 1.创建ConnectionFactory
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(URL);
// 2.创建Connection
Connection connection = connectionFactory.createConnection();
// 3.启动连接
connection.start();
// 4.创建会话（第一个参数：是否在事务中处理）
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 5.创建一个目标
Destination destination = session.createQueue(QUEUE_NAME);
// 6.创建一个消费者
MessageConsumer consumer = session.createConsumer(destination);
// 7.创建一个监听器
consumer.setMessageListener(new MessageListener() {
public void onMessage(Message message) {
TextMessage textMessage = (TextMessage)message;
try {
System.out.println("接收消息：" + textMessage.getText());
} catch (JMSException e) {
System.out.println("接收消息异常：");
e.printStackTrace();
}
}
});
// 8.关闭连接
//connection.close();
}
}3.主题模式的消息演示
主题模式
1）客户端包括发布者和订阅者
2）主体中的消息被所有订阅者消费
3）消费者不能消费订阅之前就发送到主题中的消息
1.编写AppProducer类
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
/**
* App 生产者-主题模式
* @author
*
*/
public class AppProducer {
/** 指定ActiveMQ服务的地址 */
private static final String URL = "tcp://127.0.0.1:61616";
/** 指定主题的名称 */
private static final String TOPIC_NAME = "topic-test";
public static void main(String[] args) throws JMSException {
// 1.创建ConnectionFactory
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(URL);
// 2.创建Connection
Connection connection = connectionFactory.createConnection();
// 3.启动连接
connection.start();
// 4.创建会话（第一个参数：是否在事务中处理）
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 5. 创建一个目标
Destination destination = session.createTopic(TOPIC_NAME);
// 6.创建一个生产者
MessageProducer producer = session.createProducer(destination);
for (int i = 0; i < 100; i++) {
// 7.创建消息
TextMessage textMessage = session.createTextMessage("test" + i);
// 8.发布消息
producer.send(textMessage);
System.out.println("消息发送：" + textMessage.getText());
}
// 9.关闭连接
connection.close();
}
}2.编写AppConsumer类
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
/**
* App 消费者-主题模式
* @author
*
*/
public class AppConsumer {
/** 指定ActiveMQ服务的地址 */
private static final String URL = "tcp://127.0.0.1:61616";
/** 指定主题的名称 */
private static final String TOPIC_NAME = "topic-test";
public static void main(String[] args) throws JMSException {
// 1.创建ConnectionFactory
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(URL);
// 2.创建Connection
Connection connection = connectionFactory.createConnection();
// 3.启动连接
connection.start();
// 4.创建会话（第一个参数：是否在事务中处理）
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 5.创建一个目标
Destination destination = session.createTopic(TOPIC_NAME);
// 6.创建一个消费者
MessageConsumer consumer = session.createConsumer(destination);
// 7.创建一个监听器
consumer.setMessageListener(new MessageListener() {
public void onMessage(Message message) {
TextMessage textMessage = (TextMessage)message;
try {
System.out.println("接收消息：" + textMessage.getText());
} catch (JMSException e) {
System.out.println("接收消息异常：");
e.printStackTrace();
}
}
});
// 8.关闭连接
//connection.close();
}
}4.Spring集成ActiveMQ
1.Maven依赖
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-all</artifactId>
<version>5.15.3</version>
</dependency>
<!--spring依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>4.1.7.RELEASE</version>
</dependency>2.spring配置文件
1）common.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns: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-4.3.xsd">
<!-- 开启注解：可以使用@Autowired等 -->
<context:annotation-config />
<!-- ActiveMQ为我们提供的ConnectionFactory -->
<bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
<property name="brokerURL" value="tcp://118.89.177.110:61616"></property>
</bean>
<!-- Spring jms为我们提供的连接池 -->
<bean id="connectionFactory"
class="org.springframework.jms.connection.SingleConnectionFactory">
<property name="targetConnectionFactory" ref="targetConnectionFactory"></property>
</bean>
<!-- 队列模式 -->
<bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg value="queue"></constructor-arg>
</bean>
<!-- 主题模式-->
<bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
<constructor-arg value="topic"></constructor-arg>
</bean>
</beans>2）consumer.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns: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-4.3.xsd">
<!-- 引入配置 -->
<import resource="common.xml"/>
<!-- 配置消息监听器 -->
<bean id="consumerMessageListener" class="cn.zyzpp.spring.consumer.ConsumerMessageListener"/>
<!-- 配置消息容器 -->
<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="connectionFactory" />
<!-- 队列模式 -->
<!-- <property name="destination" ref="queueDestination" /> -->
<!-- 主题模式 -->
<property name="destination" ref="topicDestination" />
<property name="messageListener" ref="consumerMessageListener" />
</bean>
</beans>3）producer.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns: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-4.3.xsd">
<!-- 引入配置 -->
<import resource="common.xml"/>
<!-- 配置JmsTemplate发送消息 -->
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory" ref="connectionFactory"></property>
</bean>
<!-- 注入实体Bean而不是接口 -->
<bean class="cn.zyzpp.spring.producer.ProducerServiceImpl"></bean>
</beans>3）生产者消费者编码
ProducerService.java
package cn.zyzpp.spring.producer;
/**
* Created by yster@foxmail.com
*/
public interface ProducerService {
void sendMessage(String message);
}
ProducerServiceImpl.java
package cn.zyzpp.spring.producer;
import javax.annotation.Resource;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
/**
* Created by yster@foxmail.com 2018年4月24日 下午7:13:27
*/
public class ProducerServiceImpl implements ProducerService {
@Autowired
private JmsTemplate jmsTemplate;
// @Resource(name = "queueDestination") //队列模式
@Resource(name = "topicDestination") //主题模式
private Destination destination;
@Override
public void sendMessage(String message) {
//使用jmsTemplate发送消息
jmsTemplate.send(destination, new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
//创建一个消息
TextMessage textMessage = session.createTextMessage(message);
return textMessage;
}
});
System.out.println("发送消息：" + message);
}
}
AppProducer.java
package cn.zyzpp.spring.producer;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Created by yster@foxmail.com
* 2018年4月24日 下午7:29:30
*/
public class AppProducer {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:producer.xml");
ProducerService service = context.getBean(ProducerService.class);
for(int i=0; i<100; i++){
service.sendMessage("消息发送："+i);
}
context.close();
}
}
ConsumerMessageListener.java
package cn.zyzpp.spring.consumer;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
/**
* Created by yster@foxmail.com
* 2018年4月24日 下午8:48:39
*/
public class ConsumerMessageListener implements MessageListener {
@Override
public void onMessage(Message message) {
TextMessage textMessage = (TextMessage) message;
try {
System.out.println("接受消息：" + textMessage.getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
}
AppConsumer.java
package cn.zyzpp.spring.consumer;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Created by yster@foxmail.com
* 2018年4月24日 下午7:29:30
*/
public class AppConsumer {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:consumer.xml");
}
}
5.ActiveMQ集群
为什么要对消息中间件集群
实现高可用，以排除单点故障引起的服务中断
实现负载均衡，以提升效率为更多客户提供服务集群方式
客户端集群：让多个消费者消费同一个队列
Broker cluster：多个Broker之间同步消息
Master Slave：实现高可用ActiveMQ失效转移（failover）-客户端配置
允许当其中一台消息服务器宕机时，客户端在传输层上重新连接到其它消息服务器
语法：failover:(uri1,…,uriN)?transportOptionstransportOptions参数说明
randomize默认为true，表示在URI列表中选择URI连接时是否采用随机策略
initialReconnectDelay默认为10，单位毫秒，表示第一次尝试重连之间等待的时间
maxReconnectDelay默认为30000，单位毫秒，最长重连的时间间隔Broker cluster集群配置-原理
NetworkConnector（网络连接器）
网络连接器主要用于配置ActiveMQ服务器与服务器之间的网络通讯方式，
用于服务器透传消息。
网络连接器分为静态连接器和动态连接器静态连接器
动态连接器
5-2 ActiveMQ集群理论
ActiveMQ Master Slace集群方案
Share nothing storage master/slave（已过时，5.8+后移除）
Shared storage master/slave 共享存储
Replicated LevelDB Store基于负责的LevelDB Store共享存储集群的原理
基于复制的LevelDB Store的原理
两种集群方式对比
三台服务器的完美集群方案
ActiveMQ集群配置方案
配置过程
1.节点准备
mkdir activemq创建目录
cp -rf apache-activemq-5.15.3 activemq/activemq-a
cp -rf apache-activemq-5.15.3 activemq/activemq-b
cp -rf apache-activemq-5.15.3 activemq/activemq-c
cd activemq
mkdir kahadb2.配置a节点
cd activemq-a/
cd conf/
vim activemq.xml
<networkConnectors>
<networkConnector name="local_network" uri="static:(tcp://127.0.0.1:61617,tcp://127.0.0.1:61618)" />
</networkConnectors>
vim jetty.xml：配置管理端口号，a节点使用默认端口，无须配置3.配置b节点
vim activemq.xml
配置网络连接器
<networkConnectors>
<networkConnector name="network_a" uri="static:(tcp://127.0.0.1:61616)" />
</networkConnectors>
配置持久化存储路径
<persistenceAdapter>
<kahaDB directory="/***/activemq/kahadb"/>
</persistenceAdapter>
配置服务端口
<transportConnector name="openwire" uri="tcp://0.0.0.0:61617?maximumConnections=1000&wireFormat.maxFrameSize=104857600"/>
vim jetty.xml
配置管理端口号
<bean id="jettyPort" class="org.apache.activemq.web.WebConsolePort" init-method="start">
<!-- the default port number for the web console -->
<property name="host" value="0.0.0.0"/>
<property name="port" value="8162"/>
</bean>4.配置c节点
vim activemq.xml
配置网络连接器
<networkConnectors>
<networkConnector name="network_a" uri="static:(tcp://127.0.0.1:61616)" />
</networkConnectors>
配置持久化存储路径
<persistenceAdapter>
<kahaDB directory="/***/activemq/kahadb"/>
</persistenceAdapter>
配置服务端口
<transportConnector name="openwire" uri="tcp://0.0.0.0:61618?maximumConnections=1000&wireFormat.maxFrameSize=104857600"/>
vim jetty.xml
配置管理端口号
<bean id="jettyPort" class="org.apache.activemq.web.WebConsolePort" init-method="start">
<!-- the default port number for the web console -->
<property name="host" value="0.0.0.0"/>
<property name="port" value="8163"/>
</bean>5.启动服务
回到activemq目录，分别启动a，b，c三个节点
./activemq-a/bin/activemq start
./activemq-b/bin/activemq start
./activemq-c /bin/activemq start检查是否都启动成功
ps -ef |grep activemq检查是否对外提供服务，即端口是否被监听（占用）
netstat -anp |grep 61616
netstat -anp |grep 61617
netstat -anp |grep 61618检查发现61618即c节点没有提供服务，但是c节点的进程是启动成功了的。因为b节点和c点击是master/slave配置，现在b节点获取到了共享文件夹的所有权，所以c节点正在等待获得资源，并且提供服务。即c节点在未获得资源之前，是不提供服务的。
测试，把b节点杀掉，看c节点能不能提供61618的服务
./activemq-b/bin/activemq stop
netstat -anp |grep 61618
./activemq-b/bin/activemq start
netstat -anp |grep 61617检查发现，重新启动b节点后，b节点61617端口并没有提供服务，是因为现在b节点成为了slave节点，而c节点成为了master节点。所以，现在b节点启动了，但是它并不对外提供服务。只有当c节点出现问题后，b节点才对外提供服务。
6.通过代码测试集群配置是否生效
生产者
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
/**
* App 生产者-队列模式-集群配置测试
* @author
*
*/
public class AppProducerTest {
/** failover 为状态转移的存在部分
* 因a节点只作为消费者使用，所以这里不配置61616节点了。
* */
private static final String URL = "failover:(tcp://127.0.0.1:61617,tcp://127.0.0.1:61618)?randomize=true";
/** 指定队列的名称 */
private static final String QUEUE_NAME = "queue-test";
public static void main(String[] args) throws JMSException {
// 1.创建ConnectionFactory
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(URL);
// 2.创建Connection
Connection connection = connectionFactory.createConnection();
// 3.启动连接
connection.start();
// 4.创建会话（第一个参数：是否在事务中处理）
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 5. 创建一个目标
Destination destination = session.createQueue(QUEUE_NAME);
// 6.创建一个生产者
MessageProducer producer = session.createProducer(destination);
for (int i = 0; i < 100; i++) {
// 7.创建消息
TextMessage textMessage = session.createTextMessage("test" + i);
// 8.发布消息
producer.send(textMessage);
System.out.println("消息发送：" + textMessage.getText());
}
// 9.关闭连接
connection.close();
}
}消费者
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
/**
* App 消费者-队列模式-集群配置测试
* @author
*
*/
public class AppConsumerTest {
/** failover 为状态转移的存在部分
* */
private static final String URL = "failover:(tcp://127.0.0.1:61616,tcp://127.0.0.1:61617,tcp://127.0.0.1:61618)?randomize=true";
/** 指定队列的名称 */
private static final String QUEUE_NAME = "queue-test";
public static void main(String[] args) throws JMSException {
// 1.创建ConnectionFactory
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(URL);
// 2.创建Connection
Connection connection = connectionFactory.createConnection();
// 3.启动连接
connection.start();
// 4.创建会话（第一个参数：是否在事务中处理）
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 5.创建一个目标
Destination destination = session.createQueue(QUEUE_NAME);
// 6.创建一个消费者
MessageConsumer consumer = session.createConsumer(destination);
// 7.创建一个监听器
consumer.setMessageListener(new MessageListener() {
public void onMessage(Message message) {
TextMessage textMessage = (TextMessage)message;
try {
System.out.println("接收消息：" + textMessage.getText());
} catch (JMSException e) {
System.out.println("接收消息异常：");
e.printStackTrace();
}
}
});
// 8.关闭连接
//connection.close();
}
}管理界面查看消息
http://127.0.0.1:8161
http://127.0.0.1:8162
http://127.0.0.1:81636.扩展
本文记录简要，推荐阅读 慕课网-Java消息中间件学习总结
Java消息中间件入门笔记 - ActiveMQ篇的更多相关文章
- Java快速入门-02-基础篇
Java快速入门-02-基础篇 上一篇应该已经让0基础的人对 Java 有了一些了解,接一篇更进一步 使用 Eclipse 快捷键 这个老师一般都经常提,但是自己不容易记住,慢慢熟练 快捷键 快捷键作 ...
- Java快速入门-01-基础篇
Java快速入门-01-基础篇 如果基础不好或者想学的很细,请参看:菜鸟教程-JAVA 本笔记适合快速学习,文章后面也会包含一些常见面试问题,记住快捷键操作,一些内容我就不转载了,直接附上链接,嘻嘻 ...
- Java GUI入门手册-AWT篇
Java GUI入门手册: AWT是基本的GUI设计工具,重点学习其中的布局格式以及事件监听事件. 首先创建一个窗口,我们先分析Frame类中的方法: 通过上图,可以看出frame是由构造方法的重载: ...
- java消息中间件入门
消息中间件来解耦服务调用 比如1个登录系统,登录的话需要调用很多系统的其他服务,如果中间调用失败,可能会导致登录信息一致无法返回,同时也增加了系统的耦合度.而用消息中间件的话,则是不发送服务到其他系统 ...
- Java菜鸟学习笔记--数组篇(三):二维数组
定义 //1.二维数组的定义 //2.二维数组的内存空间 //3.不规则数组 package me.array; public class Array2Demo{ public static void ...
- HBase 入门笔记-安装篇
一.前言 接触HBase已近半年,从一无所知到问题的解决,在数据落地方面也有了一定的了解,在此记录这半年来碰到的一些问题和对一些数据落地方面的见解,本篇主要介绍一下hbase安装方面的信息 二.安装环 ...
- Java菜鸟学习笔记--数组篇(二):数组实例&args实例
基本类型实例 //1.定义一个一维数组,先声明,在分配空间 int []number;//生命,没有初始化,number=null number=new int[5];//初始化为默认值,int默认值 ...
- Java菜鸟学习笔记--Exception篇(一):异常简介
什么是异常(Exception)? 简述: 在运行过程中,应用程序可能遭遇各种严重程度不同的问题.异常提供了一种在不弄乱程序的情况下检查错误的巧妙方式.它也提供了一种直接报告错误的机制. 不同类型异常 ...
- Java菜鸟学习笔记--面向对象篇(十五):Wrapper Class包装类
什么是包装类? 在Java里一切都是对象,除了Java中的基本数据类型(byte,short,int,long,char,float,double,boolean)不是面向对象的,这在实际使用时存在很 ...
随机推荐
- springboot 学习之路 6（集成durid连接池）
目录:[持续更新.....] spring 部分常用注解 spring boot 学习之路1(简单入门) spring boot 学习之路2(注解介绍) spring boot 学习之路3( 集成my ...
- WebAPI接口设计：SwaggerUI文档 / 统一响应格式 / 统一异常处理 / 统一权限验证
为什么还要写这类文章?因为我看过网上很多讲解的都不够全面,而本文结合实际工作讲解了swaggerui文档,统一响应格式,异常处理,权限验证等常用模块,并提供一套完善的案例源代码,在实际工作中可直接参考 ...
- 自动化测试基础篇--Selenium多窗口、句柄问题
摘自https://www.cnblogs.com/sanzangTst/p/7680402.html 有时我们在打开浏览器浏览网页时,当点击网页上某些链接时,它不是直接在当前页面上跳转,而是重新打开 ...
- django静态模版使用
第一步:在app目录下建立static文件夹,将CSS文件.js文件放到static文件夹下 第二步:TEMPLATES = [ { 'BACKEND': 'django.template.backe ...
- solidity高级理论(三)：时间单位与view
solidity高级理论(三):时间单位与view 关键字:时间单位.view.Gas优化 solidity使用自己的本地时间单位 变量 now 将返回当前的unix时间戳(自1970年1月1日以来经 ...
- 利用uWSGI和nginx进行服务器部署
搭建服务器虚拟环境 1)在本机进入虚拟环境,执行命令导出当前需要的所有包. pip freeze > plist.txt 2)通过ftp软件将项目代码和plist.txt文件上传到服务器. 3) ...
- 第八章 计时器（BEEPER1）
*------------------------------------- BEEPER1.C -- Timer Demo Program No. (c) Charles Petzold, ---- ...
- 关于hightcharts如何在同一HTML画两个及以上图形问题
---恢复内容开始--- 写这篇博文也是因为做图表展示时被在同一网页上展示两个饼图难住,关键点在于views,py文件里面的render()函数,对于这个函数有三个参数: request----默认参 ...
- SpringCloud之初识Zuul(网关)---动态路由,权限验证
通过前面的学习,使用Spring Cloud实现微服务的架构基本成型,大致是这样的: 我们使用Spring Cloud Netflix中的Eureka实现了服务注册中心以及服务注册与发现:而服务间通过 ...
- CSS 浮动(float)与定位(position)
一.浮动 1.三个属性:left.right.none. 2.特点:容易造成父项塌陷,故在父项需要清除浮动 3.父项塌陷现象 4.父项塌陷解决方案(建议使用):清除浮动 .parent:after{ ...