sql复制代码cd /usr/local/rocketmq
nohup bin/mqnamesrv &

sql复制代码cd /usr/local/rocketmq
nohup bin/mqbroker -c conf/broker.conf  &

sql复制代码cd /usr/local/rocketmq
nohup  java -jar rocketmq-console-ng-1.0.1.jar &

sql复制代码#rocketmq 
export NAMESRV_ADDR=localhost:9876

sql复制代码netstat -ntlp |grep java

sql复制代码cd /usr/local/rocketmq/
bin/tools.sh org.apache.rocketmq.example.quickstart.Producer

sql复制代码cd /usr/local/rocketmq/
bin/tools.sh org.apache.rocketmq.example.quickstart.Consumer

sql复制代码cd /usr/local/rocketmq/
sh bin/mqshutdown namesrv

sql复制代码cd /usr/local/rocketmq/
sh bin/mqshutdown broker

sql复制代码 netstat -ntlp |grep 8080
 kill -9 1836

java复制代码
public class Client {

    public static void main(String[] args) {
        Servant servant = new Servant();
        servant.service(new ConcreteServiced1());
        servant.service(new ConcreteServiced2());
    }
    /**
     * 通用功能
     */
    interface IServiced {
        //具有的特质或功能
        public void serviced();
    }

    /**
     * 具体功能
     */
    static class ConcreteServiced1 implements IServiced {
        public void serviced(){
            System.out.println("Serviced 1 doing");
        }
    }

    static class ConcreteServiced2 implements IServiced{
        public void serviced(){
            System.out.println("Serviced 2 doing");
        }
    }

    /**
     * 雇工类
     */
    static class Servant {
        //服务内容
        public void service(IServiced serviceFuture){
            serviceFuture.serviced();
        }
    }

}

java复制代码ConnectionFactory factory = new ConnectionFactory();
factory.setHost( "本地主机" );
尝试（连接连接= factory.newConnection();
     通道通道 = connection.createChannel()) {

}

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
    <version>2.6.0</version>
</dependency>

typescript复制代码/**
 * 生产者: 发送消息的程序
 *
 * @author unidentifiable
 * @date 2021/11/25
 */
@RestController
@RequestMapping("/producer")
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 队列名称
     */
    private static final String QUEUE_NAME = "hello_world";

    /**
     * 发现消息
     *
     * @param msg 待发送的消息
     * @return java.lang.String
     */
    @GetMapping("/sendMsg")
    public String sendMsg(String msg){
        // 将消息发送至指定的队列中
        rabbitTemplate.send(QUEUE_NAME, new Message(msg.getBytes(StandardCharsets.UTF_8)));
        return "消息【" + msg + "】已发出";
    }
}

java复制代码/**
 * 消费者：接收消息的程序
 *
 * @author unidentifiable
 * @date 2021/11/25
 */
@Component
public class Consumer {

    private static final String QUEUE_NAME = "hello_world";

    /**
     * 监听队列
     */
    @RabbitListener(queues = QUEUE_NAME)
    public void receive(String msg) {
        System.out.println("接收到的消息为：" + msg);
    }
}

java复制代码
public class Client {

    public static void main(String[] args) {
        ObjectFactory factory = new ObjectFactory();
        System.out.println(factory.getObject("Joe").isNill());
        System.out.println(factory.getObject("Tom").isNill());
    }


    //抽象对象
    static abstract class AbstractObject{
        abstract void request();
        abstract boolean isNill();
    }

    //空对象
    static class NullObject extends AbstractObject{

        public void request() {
            System.out.println("Not Available Request");
        }

        boolean isNill() {
            return true;
        }
    }

    //真实对象
    static class RealObject extends AbstractObject{
        private String name;
        public RealObject(String name) {
            this.name = name;
        }

        public void request() {
            System.out.println("Do samething...");
        }

        boolean isNill() {
            return false;
        }
    }

    //对象工厂
    static class ObjectFactory{
        private static final String[] names = {"Tom","Mic","James"};

        public AbstractObject getObject(String name){
            for (String n : names) {
                if(n.equalsIgnoreCase(name)){
                    return new RealObject(name);
                }
            }
            return new NullObject();
        }
    }
}

java复制代码
public class Client {

    public static void main(String[] args) {
        //待分析的对象
        List<Object> list = new ArrayList<Object>();
        //定义两个业务规格书
        ISpecification spec1 = new BizSpecification("a");
        ISpecification spec2 = new BizSpecification("b");
        //规格调用
        for (Object o : list) {
            if(spec1.and(spec2).isSatisfiedBy(o)){  //如果o满足spec1 && spec2
                System.out.println(o);
            }
        }
    }

    //抽象规格书
    interface ISpecification {
        //候选者是否满足条件
        boolean isSatisfiedBy (Object candidate) ;
        //and操作
        ISpecification and (ISpecification spec);
        //or操作
        ISpecification or (ISpecification spec);
        //not操作
        ISpecification not ();
    }

    //组合规格书
    static abstract class CompositeSpecification implements ISpecification {
        //是否满足条件由子类实现
        public abstract boolean isSatisfiedBy (Object candidate) ;
        //and操作
        public ISpecification and (ISpecification spec) {
            return new AndSpecification(this, spec);
        }
        //or操作
        public ISpecification or(ISpecification spec) {
            return new OrSpecification(this, spec);
        }
        //not操作
        public ISpecification not() {
            return new NotSpecification(this);
        }
    }

    //与规格书
    static class AndSpecification extends CompositeSpecification {
        //传递两个规格书进行and操作
        private ISpecification left;
        private ISpecification right;

        public AndSpecification(ISpecification left, ISpecification right) {
            this.left = left;
            this.right = right;
        }
        
        //进行and运算
        public boolean isSatisfiedBy(Object candidate) {
            return left.isSatisfiedBy(candidate) && right.isSatisfiedBy(candidate);
        }
    }


    static class OrSpecification extends CompositeSpecification {
        //传递两个规格书进行or操作
        private ISpecification left;
        private ISpecification right;

        public OrSpecification(ISpecification left, ISpecification right) {
            this.left= left;
            this.right = right;
        }

        //进行or运算
        public boolean isSatisfiedBy(Object candidate) {
            return left.isSatisfiedBy(candidate) || right.isSatisfiedBy(candidate);
        }
    }

    static class NotSpecification extends CompositeSpecification {
        //传递两个规格书进行非操作
        private ISpecification spec;

        public NotSpecification(ISpecification spec) {
            this.spec = spec;
        }

        //进行not运算
        public boolean isSatisfiedBy(Object candidate) {
            return !spec.isSatisfiedBy(candidate);
        }
    }

    //业务规格书
    static class BizSpecification extends CompositeSpecification {
        //基准对象，如姓名等，也可以是int等类型
        private String obj;
        public BizSpecification(String obj) {
            this.obj = obj;
        }
        //判断是否满足要求
        public boolean isSatisfiedBy(Object candidate){
            //根据基准对象判断是否符合
            return true;
        }
    }
}

java复制代码
public class Client {

    public static void main(String[] args) {
        ObjectPool pool = new ObjectPool(10,50);
        IPooledObject object = pool.borrowObject();
        object.operation();
        pool.returnObject(object);
        System.out.println();
    }

    //抽象对象
    interface IPooledObject {
        void operation();
    }
    //具体对象
    static class ConcretePoolObject implements IPooledObject {
        public void operation() {
            System.out.println("doing");
        }
    }

    //对象池
    static class ObjectPool {
        private int step = 10;  					//当对象不够用的时候，每次扩容的数量
        private int minCount;
        private int maxCount;
        private Vector<IPooledObject> returneds; 	//保存未借出的对象
        private Vector<IPooledObject> borroweds; 	//保存已被借出的对象

        //初始化对象池
        public ObjectPool(int minCount,int maxCount){
            borroweds = new Vector<IPooledObject>();
            returneds = new Vector<IPooledObject>();

            this.minCount = minCount;
            this.maxCount = maxCount;

            refresh(this.minCount);
        }

        //因为内部状态具备不变性，所以作为缓存的键
        public IPooledObject borrowObject() {
            IPooledObject next = null;
            if(returneds.size() > 0){
                Iterator<IPooledObject> i = returneds.iterator();
                while (i.hasNext()){
                    next = i.next();
                    returneds.remove(next);
                    borroweds.add(next);
                    return next;
                }
            }else{
                //计算出剩余可创建的对象数
                int count = (maxCount - minCount);
                //剩余可创建的数量大于单次固定创建的对象数
                //则再初始化一批固定数量的对象
                refresh(count > step ? step : count);
            }
            return next;
        }

        //不需要使用的对象归还重复利用
        public void returnObject(IPooledObject pooledObject){
            returneds.add(pooledObject);
            if(borroweds.contains(pooledObject)){
                borroweds.remove(pooledObject);
            }
        }

        private void refresh(int count){
            for (int i = 0; i < count; i++) {
                returneds.add(new ConcretePoolObject());
            }
        }
    }
}

xml复制代码<?xml version="1.0"?>
<books>
    <book>
        <author>Carson</author>
        <price format="dollar">31.95</price>
        <pubdate>05/01/2001</pubdate>
    </book>
    <pubinfo>
        <publisher>MSPress</publisher>
        <state>WA</state>
    </pubinfo>
</books>

ini复制代码XmlDocument xmlDoc = new XmlDocument();
xmlDoc.CreateXmlDeclaration("1.0", "utf-8", "yes");
XmlElement xmlRootNode = xmlDoc.CreateElement("books");

XmlElement bookNode = xmlDoc.CreateElement("book");
XmlElement authorNode = xmlDoc.CreateElement("author");
authorNode.InnerText="Carson";
bookNode.AppendChild(authorNode);

XmlElement authorNode = xmlDoc.CreateElement("author");
authorNode.InnerText="Carson";
bookNode.AppendChild(authorNode);

XmlElement priceNode = xmlDoc.CreateElement("price");
authorNode.InnerText="31.95";
authorNode.SetAttribute("format","dollar");
bookNode.AppendChild(priceNode);

XmlElement pubdateNode = xmlDoc.CreateElement("pubdate");
pubdateNode.InnerText="05/01/2001";
bookNode.AppendChild(pubdateNode);
xmlRootNode.AppendChild(bookNode);


XmlElement pubinfoNode = xmlDoc.CreateElement("pubinfo");

XmlElement publisherNode = xmlDoc.CreateElement("publisher");
publisherNode.InnerText="MSPress";
pubinfoNode.AppendChild(publisherNode);

XmlElement stateNode = xmlDoc.CreateElement("state");
stateNode.InnerText="WA";
pubinfoNode.AppendChild(stateNode);
xmlRootNode.AppendChild(pubinfoNode);

ini复制代码XmlWriter xmlWriter = null;

XmlWriterSettings settings = new XmlWriterSettings();
//要求缩进
settings.Indent = true;
//设置encoding utf-8,默认将输出utf-16
settings.Encoding = new UTF8Encoding(false);
//设置换行符
settings.NewLineChars = Environment.NewLine;

MemoryStream ms = new MemoryStream();
try
{
    xmlWriter = XmlWriter.Create(ms, settings);
    xmlWriter.WriteStartDocument();
    xmlDoc.WriteTo(xmlWriter);
}
finally
{
    if (xmlWriter != null)
        xmlWriter.Close();
    ms.Close();
}
string xmlStr=Encoding.UTF8.GetString(ms.ToArray());

python复制代码import time
import requests
from bs4 import BeautifulSoup

headers = {
    'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36'
}
for i in range(1, 13):
    time.sleep(5)
    # 把1转换为01
    url = 'http://www.tianqihoubao.com/aqi/tianjin-2017' + str("%02d" % i) + '.html'
    response = requests.get(url=url, headers=headers)
    soup = BeautifulSoup(response.text, 'html.parser')
    tr = soup.find_all('tr')
    # 去除标签栏
    for j in tr[1:]:
        td = j.find_all('td')
        Date = td[0].get_text().strip()
        Quality_grade = td[1].get_text().strip()
        AQI = td[2].get_text().strip()
        AQI_rank = td[3].get_text().strip()
        PM = td[4].get_text()
        with open('air_tianjin_2017.csv', 'a+', encoding='utf-8-sig') as f:
            f.write(Date + ',' + Quality_grade + ',' + AQI + ',' + AQI_rank + ',' + PM + '\n')

sql复制代码--不需要这样
CREATE TABLE em.emp(id int); 
--可以这样
CREATE TABLE emp(id int);

sql复制代码oa=# show search_path;
   search_path
-----------------
 "$user", public
(1 row)

sql复制代码--测试名字与schema名不同的用户，即使有访问 schema 的权限，连入时也不是当前 schema。
oa=# \dn
  List of schemas
  Name  |  Owner
--------+----------
 em     | postgres
 op     | postgres
 public | postgres
 rl     | postgres
(4 rows)
oa=# \c - syd
You are now connected to database "oa" as user "syd".
oa=> select current_schema;
 current_schema
----------------
 public
(1 row)

oa=# grant USAGE on schema rl to syd;
GRANT
oa=# \c - syd
You are now connected to database "oa" as user "syd".
oa=> select current_schema;
 current_schema
----------------
 public
(1 row)

--测试与 schema 同名用户，需要有访问该 schema 的权限，连入时才为当前 schema。（两种授权访问 schema 模式的方法）
oa=> \c - em
You are now connected to database "oa" as user "em".
oa=> select current_schema;
 current_schema
----------------
 public
(1 row)

oa=> \dn
  List of schemas
  Name  |  Owner
--------+----------
 em     | postgres
 op     | postgres
 public | postgres
 rl     | postgres
(4 rows)

--1）更改 schema 的 owner 为这个用户，用户自然就具有了访问 schema 的权限
oa=> \c - postgres
You are now connected to database "oa" as user "postgres".
oa=# alter schema em owner to em;
ALTER SCHEMA
oa=# \dn
  List of schemas
  Name  |  Owner
--------+----------
 em     | em
 op     | postgres
 public | postgres
 rl     | postgres
(4 rows)
oa=# \c - em
You are now connected to database "oa" as user "em".
oa=> select current_schema;
 current_schema
----------------
 em
(1 row)

--2）直接授予用户访问 schema 的权限
oa=# \dn
  List of schemas
  Name  |  Owner
--------+----------
 em     | em
 op     | postgres
 public | postgres
 rl     | rl
(4 rows)

oa=# \c - op
You are now connected to database "oa" as user "op".
oa=> select current_schema;
 current_schema
----------------
 public
(1 row)

oa=> \c - postgres
oa=# grant USAGE on schema op to op;
GRANT
oa=# \c - op
You are now connected to database "oa" as user "op".
oa=> select current_schema;
 current_schema
----------------
 op
(1 row)

sql复制代码oa=# alter user syd set search_path to rl;
ALTER ROLE
oa=# \c - syd
You are now connected to database "oa" as user "syd".
oa=> \dn
  List of schemas
  Name  |  Owner
--------+----------
 em     | em
 op     | postgres
 public | postgres
 rl     | rl
(4 rows)

oa=> select current_schema;
 current_schema
----------------
 rl
(1 row)

sql复制代码--设置 apply_owner 用户连入任何数据库，当前默认 schema 都为 apply(数据库中没有这 schema 时,默认 schema 为 public)   
alter user apply_owner set search_path to apply; 
--设置任何用户连入 chis 数据库，当前默认 schema 都为 apply 
alter database chis set search_path to apply; 
--用户名与 schema 同名，且用户具有访问改 schema 的权限，用户连入数据库时，默认即为当前 schema 
create database chis; 
\c chis create schema apply; 
create user apply password '11111'; 

grant USAGE on schema apply to apply;
或
alter schema apply owner to apply;