区块链开源项目推荐,区块链开源项目java

在当今的区块链技术发展迅速的时代，开源项目的重要性也在不断增加。其中，Java开源项目可以说是区块链技术发展的重要支柱，它们为区块链技术的发展提供了强大的支持。下面就来介绍几个比较出名的Java开源项目。

Ethereum：

Ethereum是一个开放源代码、公共、分布式计算平台，它使开发者能够构建和发布下一代分布式应用程序。它使用智能合约进行交易，从而实现去中心化的自治组织。Ethereum的基础架构是一个基于以太坊协议的区块链网络，它使用Solidity编程语言编写智能合约。

Hyperledger Fabric：

Hyperledger Fabric是一个由Linux基金会管理的开源分布式账本技术，它由一系列模块构成，可以让开发者构建和部署基于区块链的应用程序。它支持多种编程语言，包括Java、Go和Node.js，从而使开发者可以使用它来构建复杂的分布式应用程序。它还支持多种智能合约，包括JavaScript和Go，以及支持多种身份验证方案，从而使开发者可以使用它来构建安全的应用程序。

Hyperledger Sawtooth：

Hyperledger Sawtooth是一个由Linux基金会管理的开源分布式账本技术，它由一系列模块构成，可以让开发者构建和部署基于区块链的应用程序。它支持多种编程语言，包括Java、Go和Python，从而使开发者可以使用它来构建复杂的分布式应用程序。它还支持多种智能合约，包括JavaScript和Python，以及支持多种身份验证方案，从而使开发者可以使用它来构建安全的应用程序。

以上就是三个比较出名的Java开源项目，它们为区块链技术的发展提供了强大的支持，可以说是区块链技术发展的重要支柱。在未来，我们将会看到更多这样的开源项目出现，为区块链技术的发展提供更多的支持。

请查看相关英文文档

Will Web3 make the future of open source better?

I recently read an article by Joey DeBruin and was very moved. Many great software in history were born from the open source movement. So in the next era that puts more emphasis on collaboration, or in other words, what can Web3 bring to the open source industry? Some of the views in this article may be somewhat controversial, but the purpose of publishing this article is to provide everyone with a direction for thinking.

Foreword

"Tokenization of Web3 may provide a business model for open source contributors. The correlation between the two does exist, but the form is worth exploring"

Many opinions have mentioned that Web3 and encryption technology can solve a series of problems such as data monopoly and algorithm control, but I think that exploring this problem requires thinking from a more fundamental level:

Open source: Where we are today Many of the computer software and other products we use rely on open source. Open source provides many basic components for many of the products we use. These components are like the bricks that build a house.

In this article, we talk about the relationship between Web3 and open source, which may inspire you.

The rise of open source

First of all, when talking about the connection between open source and Web3, you need to understand the following points:

Understanding the above issues will help you understand How today's Web3 is riding on the trend of open source, continuing to iterate the open source model in various ways, helping decentralized communities get more economic incentives, and consolidating the overall growth and inclusiveness of decentralized communities.

Open source, as its name suggests, is that the source code is public and can be seen by anyone in public mode. If you want to read, download, or optimize or use it according to your own purposes, you can directly find Linux (the mainstream classic open source operating system)

For example: To some extent, the open source model can be understood as Wikipedia, but in this article we are not talking about editing entries together, but about everyone joining together to write valuable software. What's more interesting is that what makes open source useful and trustworthy is that you can "Fork" the project, that is, you can rewrite the code according to your own needs. As a result, many open source projects evolve into dominant tools in a field because people don't feel nervous or feel restricted because the software they rely on is a monopoly product.

In a recent Forrester report, 96% of companies felt that "open source is very important to the business and a critical mission", and 98% of companies planned to increase or maintain their focus on open source in the next year. Strategy. There are also reports showing that Linux isThe first choice for modern server operating systems. 96.3% of the top 1 million web servers are running Linux, and open source is basically a key part of many of the widely used technologies we see today.

Want to learn more about the nature of the open source drive? It is highly recommended to read two books:

"Cathedrals and Bazaars" or "Penguins of Cos" This part mainly includes two points:

Git or Wikis (these two allow many Technologies such as people working in parallel will further reduce coordination costs.

This means that different groups of people can come together to produce software that is on the same level as, or even better than, the closed-source versions created and sold by traditional companies. But why do we do this? Usually because they think it's interesting, or because they are users of the software themselves and don't want to pay, or because they can make a living doing it.

To summarize: the trend of powering open source has just begun and has been going on for decades before, and I don’t think this is a flash in the pan.

In most cases, independent open source developers are paid really little compared to the value created, or compared to the money a tech guru could make in a "traditional" tech job. is trivial. And open source projects receive insufficient resources compared to the value they can provide. Thus. When problems arise, the general public can feel the power of open source...

Tell a story: The Heartbleed Bug vulnerability a few years ago led to the leakage of encrypted user data in tens of millions of servers. The Heartbleed Bug allows anyone on the Internet to read system protected memory. Attackers can eavesdrop on communications at will and steal data directly from service providers by impersonating service providers and users. Data on 4.5 million patients in U.S. hospital systems and records stolen.

Last year's "Log4j2" vulnerability affected many technology giants. The cartoon below is funny, but also scary, and it's done so accurately.

In other words: Although open source has huge value, due to the nature of public goods, in many key projects, open source strives to maintain only a little bit of its own light and heat.

Web3 and Service Model

There are indeed viable business models in open source, and there are many multi-billion dollar companies built on open source projects. A very typical example is Red Hat.

Red Hat sells services to companies that want to use Linux. Specifically, corporate customers pay a fee to get customized, secure andAdvanced SaaS products with privacy features, rather than directly using the open source version, Red Hat can help enterprises customize Linux services. Red Hat was acquired by IBM for 34 billion in 2019, with annual revenue reaching billions of dollars.

However, the problem with these centralized business models is that these business models actually rely on many decentralized counterparts. What makes Linux so valuable is the thousands of contributors who provide stability and integration that no other operating system can provide.

If Red Hat tried to produce Linux in-house with its own employees, it would probably fail. This is the same as how Wikipedia entries are better than centralized encyclopedias like the Encyclopedia Britannica: Peer Proction trumps hierarchy when it comes to creating certain types of goods, which is where our argument for Web3 lies today.

Many Linux developers live on meager donations (from Red Hat and other similar companies), but Red Hat can just add a layer on top and the revenue can reach dozens of dollars per year. At a price of $100 million, this may seem a bit strange. So why don't all these Linux developers build the enterprise layer themselves and use the profits to fund everyone's work?

To answer this question, we need to consider the steps the Linux community must take to achieve this goal:

Note that these are essentially coordination costs, and coordination costs are not Low, and coordination is what the corporate model is good at. Therefore, a separate company can be formed to do these things. However, the major challenge in allocating equity to Linux development contributors around the world is that equity distribution is very difficult to balance. Therefore, we can only maintain this decentralized and open relationship with developers, going around and around. Back again...

But what if there was a more flexible way to coordinate digital ownership? This is what Web3 wants to do, imagine we do the same steps above, but coordinate through Tokens.

Of course, the current Web3 still has certain problems and still needs iteration, but these current things can now be done by those who are willing to be pioneers. There are tools to create DAOs with one click, ways to tie revenue directly to governance tokens, and systems to reward contributors based on a level of contribution determined by the community.

The DAO and the Beer Business

Richard Stallman founded the free software movement and the GNU Project, one of the origins of open source. Stallman proposed: “Free as in speech, not as in beer." Free software mainly pursues public interests and digital freedom rights.

Pictured: Richard Stallman

Then, open source software also developed. However, currently In the field of open source, software is often used "for free", but this is not because large companies refuse to pay for services, but because the mainstream model of software now is "SaaS - software as a service".

Instead of purchasing a perpetual license, companies pay a monthly service fee to use the current version of the product (usually on the cloud). Commercial companies pay for this convenience, and this model is where open source can be applied Large-scale business models built.

If you tie it all together, the reason why open source has always been as free as beer is because the coordination costs between open source projects and their service-based counterparts are too high. This is Why are we mentioning here today why tokenization and the decentralized community have such huge opportunities?

Of course, there are already large companies using this model of binding service businesses with decentralized protocols. From Braintree, Parsiq, most centralized exchanges, to Ethereum itself. These service businesses come in many forms: For example, Ethereum’s service is to provide computing power for applications in the world, while on Braintree, the services provided are mainly Help traditional businesses by providing payment solutions for various new modes (cryptocurrencies).

Braintree is a Chicago-based company that specializes in providing mobile and online payment systems for e-commerce companies. Braintree also accepts Bitcoin For payments and transactions, users can open an account at Coinbase and then link the new account to Braintree.

Let’s look at this picture again now:

However, not all of these platforms themselves All are open source, but importantly, the revenue tied to the service model will directly feed back to the value of the local token. In this case, over time, the incentive to promote open source will be huge, because it A more vibrant developer and service-based ecosystem can be allowed to continue, and the project will strive to operate in the best interest of the entire network (because if it doesn't, it can be "forked" by others Fork can then be rewritten into a better version).

Of course, tokenized and decentralized communities will not be the only feasible models in the future. Nor are they the only innovations possible through cryptocurrency . BTC is digital gold, and NFT can be understood as a safe for digital assets. The impact of these encryption origins and basic characteristics areIt could have a profound impact on the future of open source. But I think the reason why this particular field is so exciting is that the decentralized community is not only building open source, but also reconstructing many things in our modern life and optimizing many of the systems that currently exist.

And this doesn't just include code. Think of Wikipedia, Facebook, Uber, Linux - all of these projects were started by a small number of people working to define the rules of the platform, and then a large number of people participating in building the value. The difficulty in capturing and distributing value in these communities takes many forms, from the Facebook or Uber model, where a few people capture huge value, to the Wikipedia or Linux model, where almost no one directly benefits financially. Then, the structure described above can be applied to Facebook, just like Linux, where users participate in the creation and acquisition of value.

The reason I entered the Web3 field is my lifelong connection and commitment to science, which is the world's most important public good. The biggest problem I see is that with public goods that rely on donations or funding, if there is no direct link to the value of the product, the resources are never enough compared to their impact. Web3 provides new business models through more flexible and dynamic forms of digital ownership, in which decentralized organizations and public goods can be directly linked to equity and revenue streams through tokens.

If this can be done, the open source foundation that can be built will be greatly increased and provide the impetus for a more innovative and equitable world.

㈡ How to develop blockchain

Share Zone View Network:

The application scope of blockchain technology is still very wide. Based on decentralization, decentralization With features such as trust, collective maintenance, and reliable database, its application in the financial industry is one step ahead.
Blockchain is the underlying technology of Bitcoin, and the application development of blockchain in digital currency is already mature.

Like the blockchain-based trading system development solution provided by Yingtang Zhongchuang, the developed software system has a high degree of security and transparency.

Does the code of blockchain projects need to be sourced? Why

Blockchain is a consensus mechanism, which means that such participants must be transparent, that is, The code that runs this way must be open source code. The so-called open source code means that the code is all visible.

Everyone can compile and execute the program they compiled, which also means that everyone can modify the code and run it. Under the current mechanism, it can be done no matter how the code is modified, as long as those who modify the code If people do not exceed 51%, then this kind of modification is meaningless and will instead waste your own computing power.

So, at least the people involved must know the code. If a blockchain project does not have the codeOpen source, then the nodes running its programs are opaque, which is equivalent to installing his agent on your own node and executing commands on behalf of everyone. It is equivalent to system developers controlling the entire network. How is this kind of blockchain possible?

From a conceptual perspective, if the blockchain project is compared to a machine, its working mechanism is transparent and it is a trustworthy machine. This is how we understand this. First, open source is a must for blockchain projects, not an option. Both public chains and alliance projects need to be open source. Second, open source and delivering source code are two different things. Different concepts, delivering source code is not an open, transparent, and joint process for everyone to participate.

For example, in Ethereum, a certain platform currency running on its platform once had a vulnerability and needed to be modified. This modification was directly reflected in the code. In the process of reading the code , I found that the relevant code of the currency appears in many places, which is used to deal with how the node should deal with this problem once it encounters this problem. These processing methods are all written in open source code and everyone can read it. If the person in charge of the node If he approves this solution, he will run this program, which is equivalent to supporting the decision of this code. In fact, the blockchain is implemented through this mechanism.

㈣ What is a decentralized application (DApp)?

Decentralized applications (DApps) are applications that run on a distributed computing system, that is, a blockchain network. While there are many ways to define DApps, they are often described as applications that have the following characteristics:

DApps attempt to solve multiple problems in legacy applications. The main benefit of choosing DApps over traditional applications is that the latter use a centralized architecture that stores data on servers controlled by a single entity. This means they have a single point of failure and are vulnerable to technical issues and malicious attacks.

A compromised central server could shut down an application's entire network, rendering it temporarily or permanently unusable. On top of this, centralized systems often suffer data breaches or theft, putting companies and individual users at risk.

There are a variety of DApps with different use cases. They may include games, social media platforms, cryptocurrency wallets, and financial applications (DeFi).

Decentralized applications drive their activities through a tokenization system (digital tokens created through the use of smart contracts). Tokens can be specific to a particular DApp (for example, the Steem token used on Steemit), or they can be native to the blockchain that hosts the DApp, such as CryptoKitties, which uses Ethereum (ETH).

In summary, DApps are designed as open source projects that run on top of a blockchain network. In turn, the distributed nature of these networks provides transparency, decentralization, and resistance to attacks.

This is the Rabbit community. Everyone is welcome to pay attention. We will continue to share high-quality currency content! Popularize blockchain knowledge!

㈤ How to view the spring source code

1. Preparation: After downloading the Spring source code from the official website, import it into Eclipse to facilitate query.
2. Open the project we use Spring, find the website system configuration file Web.xml, and find the Spring initialization information in it:


org.springframework.web.context.ContextLoaderListener


As can be seen from the configuration information, our starting point is the listener ContextLoaderListener.
In the source code we found this class, its definition is:
public class ContextLoaderListener extends ContextLoader
implements ServletContextListener {
…
/**
* Initialize the root web application context.
*/
public void contextInitialized(ServletContextEvent event) {
this.contextLoader = createContextLoader();
if (this.contextLoader == null) {
this.contextLoader = this;
}
this.contextLoader.initWebApplicationContext(event.getServletContext());
}
...
}

This class continues ContextLoader and implements the listener.Information loading, configuration and initialization about Spring start from here. For more details, read and write an article to learn more.
2. About IOC and AOP
About Spring IOC. There are many related articles on the Internet that you can read. So what knowledge points do we learn from them?
1) IOC container and AOP aspect dependency injection are the core of Spring.
IOC containers provide convenience and basic services for developers to manage dependencies between objects, among which Bean Factory (BeanFactory) and Context (ApplicationContext) are the manifestations of IOC. BeanFactory is an interface class, which only provides definitions for the most basic services provided by the container, while DefaultListTableBeanFactory, XmlBeanFactory, ApplicationContext, etc. are all specific implementations.
Interface:

public interface BeanFactory {
//Here is the escape definition of the factory bean, because if the bean name is used to retrieve the IOC container, the object obtained is generated by the factory bean. Object,
//If you need to get the factory Bean itself, you need to use the escaped name to retrieve it from the IOC container
String FACTORY_BEAN_PREFIX = "&";
//Here based on the name of the bean, Get bean instances in the IOC container. This IOC container is like a large abstract factory. Users can get the required beans according to their names
//In Spring, the difference between beans and ordinary JAVA objects is:
//Bean already includes the processing of dependencies in our Bean definition information. At the same time, Bean has been placed in the IOC container for management and has its own life cycle
Object getBean(String name) throws BeansException ;
//Here, the bean instance is obtained based on the bean name and Class type. The difference from the above method is that it will throw an exception: if the Class type of the bean instance obtained by the root name is different from the required one.
Object getBean(String name, Class requiredType) throws BeansException;
//Retrieval of beans is provided here to see if there is a bean with this name in the IOC container
boolean ccontainsBean(String name);
//Here we get the bean instance based on the bean name, and at the same time determine whether the bean is a singleton. During configuration, the default bean is configured as a singleton. If a singleton is not required, The form requires the user to mark it in the Bean definition information, so that every time the IOC container receives the user's getBean request, it will generate a new Bean and return it to the customer for use - this is the Prototype form
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
//The Class type of the bean instance is obtained here
Class getType(String name) throws NoSuchBeanDefinitionException;
//The alias of the bean is obtained here. If the alias is retrieved, then Its original name will also be retrieved
String[] getAliases(String name);
}

Implementation:
The implementation of XmlBeanFactory is as follows:
public class It is separated from container registration and dependency injection, so that a flexible bean definition reading mechanism can be used.
private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);
//A Bean definition information of Resource type is required here. The actual positioning process is completed by the Resource construction process.
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
//Use the reader in the initialization function to read the resource, Get bean definition information. This completes the entire IOC container loading and registration process of Bean definition information
public ㈥ What are the blockchain scenario application projects?

According to the latest data, developing an app probably costs tens of thousands to several million.

There are many factors to consider when developing an Android app software. If it is an APP with simple but not comprehensive functions and few customer requirements, you only need to ask the artist to modify the front-end UI page to a certain extent, which can be completed in as little as one or two days, and the cost will be several thousand yuan.

To develop a complete Android app, a simple one requires tens of thousands, and a complex one requires tens or millions. Android is not more difficult than IOS, and many teams can contract it.

(6) Extended reading of the blockchain open source project spring:

Software maintenance

1. Delete the useless installation package apk in time after installing the App

p>

Mobile phones and personal computers are very similar, and they have many similarities in maintenance methods. Nowadays, many ROMs that have been improved by mobile phone manufacturers are very considerate. Generally, after installing an App, you will be reminded whether to delete the installation package. If there is no other use, you can delete it immediately. If the mobile phone does not have this function, you can also delete it manually. .

2. Clear the cache regularly

Long-term use of social applications will generate a lot of cache, and the application itself will not delete it. Over a long period of time, a lot of cache will be accumulated, occupying storage space and causing It is stuck, so you can use the clear cache function in the application management in the phone settings to delete it. You can also use a system maintenance app that has the function of cleaning up junk. You can also uninstall and reinstall it.

3. Close unused programs promptly when using them

Although the Android system will automatically end some processes when memory is tight, in actual applications, you should have the awareness to prepare for a rainy day. , usually just end the currently unused apps on the multi-tasking interface to release the current running memory of the phone, which not only helps the phone run efficiently, but also prevents the traffic from being wasted when its background software is running.

㈦ If you are learning the secondary development of blockchain, which open source library is better to use as the basis?

This is a relatively professional question, and you need to find professional knowledge to explain it. However, the open source projects Bitcoin, Ethereum, and DECENT are all projects that can be used for reference and can be studied.
Of course, blockchain itself is just a technology, technologyAll have two sides.

What are the blockchain development tools?

Blockchain development tools are:

1. RemixIDE, the Ethereum computing platform is a block chain Chain's open source code distribution platform. The platform used to build Ethereum is x86-64Arm. The Ethereum platform uses many tools for the blockchain to create and deploy smart contracts. Remix is ​​one of them.

2.TruffleFramework, Ethereum-based applications are built under a framework called Truffle. It provides a flexible development environment including libraries that can enhance the customization of coding for new contracts and link with Ethereum-based applications. It also performs contract testing through an automated process using Chai and Mocha.